]> 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
Changed how the stock objects (wx.RED, wx.RED_PEN, wx.RED_BRUSH, etc.)
[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 bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3742
3743 void wxApp_CleanUp() {
3744 __wxPyCleanup();
3745 }
3746
3747
3748 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3749
3750
3751
3752
3753
3754 SWIGINTERNINLINE PyObject *
3755 SWIG_FromCharPtr(const char *cptr)
3756 {
3757 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3758 }
3759
3760
3761 #if 0 // #ifdef __WXMAC__
3762
3763 // A dummy class that raises an exception if used...
3764 class wxEventLoop
3765 {
3766 public:
3767 wxEventLoop() { wxPyRaiseNotImplemented(); }
3768 int Run() { return 0; }
3769 void Exit(int rc = 0) {}
3770 bool Pending() const { return false; }
3771 bool Dispatch() { return false; }
3772 bool IsRunning() const { return false; }
3773 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3774 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3775 };
3776
3777 #else
3778
3779 #include <wx/evtloop.h>
3780
3781 #endif
3782
3783
3784
3785 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3786 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3787 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3788 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3789 wxWindowList& list = self->GetChildren();
3790 return wxPy_ConvertList(&list);
3791 }
3792 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3793 #if wxUSE_HOTKEY
3794 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3795 #else
3796 return false;
3797 #endif
3798 }
3799 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3800
3801
3802
3803 return false;
3804
3805 }
3806 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3807 return wxPyGetWinHandle(self);
3808 }
3809 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3810 self->AssociateHandle((WXWidget)handle);
3811 }
3812 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3813
3814 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3815 return wxWindow::FindWindowById(id, parent);
3816 }
3817
3818 wxWindow* wxFindWindowByName( const wxString& name,
3819 const wxWindow *parent = NULL ) {
3820 return wxWindow::FindWindowByName(name, parent);
3821 }
3822
3823 wxWindow* wxFindWindowByLabel( const wxString& label,
3824 const wxWindow *parent = NULL ) {
3825 return wxWindow::FindWindowByLabel(label, parent);
3826 }
3827
3828
3829 #ifdef __WXMSW__
3830 #include <wx/msw/private.h> // to get wxGetWindowId
3831 #endif
3832
3833
3834 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3835 #ifdef __WXMSW__
3836 WXHWND hWnd = (WXHWND)_hWnd;
3837 long id = wxGetWindowId(hWnd);
3838 wxWindow* win = new wxWindow;
3839 if (parent)
3840 parent->AddChild(win);
3841 win->SetEventHandler(win);
3842 win->SetHWND(hWnd);
3843 win->SetId(id);
3844 win->SubclassWin(hWnd);
3845 win->AdoptAttributesFromHWND();
3846 win->SetupColours();
3847 return win;
3848 #else
3849 wxPyRaiseNotImplemented();
3850 return NULL;
3851 #endif
3852 }
3853
3854
3855 PyObject* GetTopLevelWindows() {
3856 return wxPy_ConvertList(&wxTopLevelWindows);
3857 }
3858
3859
3860 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3863
3864 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3865
3866
3867 SWIGINTERNINLINE int
3868 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3869 {
3870 unsigned long v;
3871 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3872 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3873 return res;
3874 }
3875
3876 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3877 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3878 wxMenuItemList& list = self->GetMenuItems();
3879 return wxPy_ConvertList(&list);
3880 }
3881 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3882 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3883 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3884 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3885 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3886 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3887 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3888 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3889 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3890 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3891 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3892 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3893 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3894 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3895 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3896 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3897 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3898 static const wxString wxPyControlNameStr(wxControlNameStr);
3899 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3900 if (clientData) {
3901 wxPyClientData* data = new wxPyClientData(clientData);
3902 return self->Append(item, data);
3903 } else
3904 return self->Append(item);
3905 }
3906 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3907 if (clientData) {
3908 wxPyClientData* data = new wxPyClientData(clientData);
3909 return self->Insert(item, pos, data);
3910 } else
3911 return self->Insert(item, pos);
3912 }
3913 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3914 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3915 if (data) {
3916 Py_INCREF(data->m_obj);
3917 return data->m_obj;
3918 } else {
3919 Py_INCREF(Py_None);
3920 return Py_None;
3921 }
3922 }
3923 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3924 wxPyClientData* data = new wxPyClientData(clientData);
3925 self->SetClientObject(n, data);
3926 }
3927
3928
3929 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3930 wxPyUserData* data = NULL;
3931 if ( userData ) {
3932 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3933 data = new wxPyUserData(userData);
3934 wxPyEndBlockThreads(blocked);
3935 }
3936 return new wxSizerItem(window, proportion, flag, border, data);
3937 }
3938 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3939 wxPyUserData* data = NULL;
3940 if ( userData ) {
3941 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3942 data = new wxPyUserData(userData);
3943 wxPyEndBlockThreads(blocked);
3944 }
3945 return new wxSizerItem(width, height, proportion, flag, border, data);
3946 }
3947 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3948 wxPyUserData* data = NULL;
3949 if ( userData ) {
3950 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3951 data = new wxPyUserData(userData);
3952 wxPyEndBlockThreads(blocked);
3953 }
3954 return new wxSizerItem(sizer, proportion, flag, border, data);
3955 }
3956
3957 #include <float.h>
3958
3959
3960 SWIGINTERN int
3961 SWIG_AsVal_float (PyObject * obj, float *val)
3962 {
3963 double v;
3964 int res = SWIG_AsVal_double (obj, &v);
3965 if (SWIG_IsOK(res)) {
3966 if ((v < -FLT_MAX || v > FLT_MAX)) {
3967 return SWIG_OverflowError;
3968 } else {
3969 if (val) *val = static_cast< float >(v);
3970 }
3971 }
3972 return res;
3973 }
3974
3975
3976 SWIGINTERNINLINE PyObject *
3977 SWIG_From_float (float value)
3978 {
3979 return SWIG_From_double (value);
3980 }
3981
3982 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3983 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3984 if (data) {
3985 Py_INCREF(data->m_obj);
3986 return data->m_obj;
3987 } else {
3988 Py_INCREF(Py_None);
3989 return Py_None;
3990 }
3991 }
3992 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3993 wxPyUserData* data = NULL;
3994 if ( userData ) {
3995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3996 data = new wxPyUserData(userData);
3997 wxPyEndBlockThreads(blocked);
3998 }
3999 self->SetUserData(data);
4000 }
4001
4002 // Figure out the type of the sizer item
4003
4004 struct wxPySizerItemInfo {
4005 wxPySizerItemInfo()
4006 : window(NULL), sizer(NULL), gotSize(false),
4007 size(wxDefaultSize), gotPos(false), pos(-1)
4008 {}
4009
4010 wxWindow* window;
4011 wxSizer* sizer;
4012 bool gotSize;
4013 wxSize size;
4014 bool gotPos;
4015 int pos;
4016 };
4017
4018 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4019
4020 wxPySizerItemInfo info;
4021 wxSize size;
4022 wxSize* sizePtr = &size;
4023
4024 // Find out what the type of the item is
4025 // try wxWindow
4026 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4027 PyErr_Clear();
4028 info.window = NULL;
4029
4030 // try wxSizer
4031 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4032 PyErr_Clear();
4033 info.sizer = NULL;
4034
4035 // try wxSize or (w,h)
4036 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4037 info.size = *sizePtr;
4038 info.gotSize = true;
4039 }
4040
4041 // or a single int
4042 if (checkIdx && PyInt_Check(item)) {
4043 info.pos = PyInt_AsLong(item);
4044 info.gotPos = true;
4045 }
4046 }
4047 }
4048
4049 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4050 // no expected type, figure out what kind of error message to generate
4051 if ( !checkSize && !checkIdx )
4052 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4053 else if ( checkSize && !checkIdx )
4054 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4055 else if ( !checkSize && checkIdx)
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4057 else
4058 // can this one happen?
4059 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4060 }
4061
4062 return info;
4063 }
4064
4065 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4066 if (!self->GetClientObject())
4067 self->SetClientObject(new wxPyOORClientData(_self));
4068 }
4069 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4070
4071 wxPyUserData* data = NULL;
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4074 if ( userData && (info.window || info.sizer || info.gotSize) )
4075 data = new wxPyUserData(userData);
4076 if ( info.sizer )
4077 PyObject_SetAttrString(item,"thisown",Py_False);
4078 wxPyEndBlockThreads(blocked);
4079
4080 // Now call the real Add method if a valid item type was found
4081 if ( info.window )
4082 return self->Add(info.window, proportion, flag, border, data);
4083 else if ( info.sizer )
4084 return self->Add(info.sizer, proportion, flag, border, data);
4085 else if (info.gotSize)
4086 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4087 proportion, flag, border, data);
4088 else
4089 return NULL;
4090 }
4091 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4092
4093 wxPyUserData* data = NULL;
4094 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4095 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4096 if ( userData && (info.window || info.sizer || info.gotSize) )
4097 data = new wxPyUserData(userData);
4098 if ( info.sizer )
4099 PyObject_SetAttrString(item,"thisown",Py_False);
4100 wxPyEndBlockThreads(blocked);
4101
4102 // Now call the real Insert method if a valid item type was found
4103 if ( info.window )
4104 return self->Insert(before, info.window, proportion, flag, border, data);
4105 else if ( info.sizer )
4106 return self->Insert(before, info.sizer, proportion, flag, border, data);
4107 else if (info.gotSize)
4108 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4109 proportion, flag, border, data);
4110 else
4111 return NULL;
4112 }
4113 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4114
4115 wxPyUserData* data = NULL;
4116 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4117 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4118 if ( userData && (info.window || info.sizer || info.gotSize) )
4119 data = new wxPyUserData(userData);
4120 if ( info.sizer )
4121 PyObject_SetAttrString(item,"thisown",Py_False);
4122 wxPyEndBlockThreads(blocked);
4123
4124 // Now call the real Prepend method if a valid item type was found
4125 if ( info.window )
4126 return self->Prepend(info.window, proportion, flag, border, data);
4127 else if ( info.sizer )
4128 return self->Prepend(info.sizer, proportion, flag, border, data);
4129 else if (info.gotSize)
4130 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4131 proportion, flag, border, data);
4132 else
4133 return NULL;
4134 }
4135 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4137 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4138 wxPyEndBlockThreads(blocked);
4139 if ( info.window )
4140 return self->Remove(info.window);
4141 else if ( info.sizer )
4142 return self->Remove(info.sizer);
4143 else if ( info.gotPos )
4144 return self->Remove(info.pos);
4145 else
4146 return false;
4147 }
4148 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4151 wxPyEndBlockThreads(blocked);
4152 if ( info.window )
4153 return self->Detach(info.window);
4154 else if ( info.sizer )
4155 return self->Detach(info.sizer);
4156 else if ( info.gotPos )
4157 return self->Detach(info.pos);
4158 else
4159 return false;
4160 }
4161 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4163 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4164 wxPyEndBlockThreads(blocked);
4165 if ( info.window )
4166 return self->GetItem(info.window);
4167 else if ( info.sizer )
4168 return self->GetItem(info.sizer);
4169 else if ( info.gotPos )
4170 return self->GetItem(info.pos);
4171 else
4172 return NULL;
4173 }
4174 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4176 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4177 wxPyEndBlockThreads(blocked);
4178 if ( info.window )
4179 self->SetItemMinSize(info.window, size);
4180 else if ( info.sizer )
4181 self->SetItemMinSize(info.sizer, size);
4182 else if ( info.gotPos )
4183 self->SetItemMinSize(info.pos, size);
4184 }
4185 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4186 wxSizerItemList& list = self->GetChildren();
4187 return wxPy_ConvertList(&list);
4188 }
4189 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4191 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4192 wxPyEndBlockThreads(blocked);
4193 if ( info.window )
4194 return self->Show(info.window, show, recursive);
4195 else if ( info.sizer )
4196 return self->Show(info.sizer, show, recursive);
4197 else if ( info.gotPos )
4198 return self->Show(info.pos, show);
4199 else
4200 return false;
4201 }
4202 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4205 wxPyEndBlockThreads(blocked);
4206 if ( info.window )
4207 return self->IsShown(info.window);
4208 else if ( info.sizer )
4209 return self->IsShown(info.sizer);
4210 else if ( info.gotPos )
4211 return self->IsShown(info.pos);
4212 else
4213 return false;
4214 }
4215
4216 // See pyclasses.h
4217 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4218 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4219 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4220
4221
4222
4223
4224 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4225 {
4226 if (source == Py_None) {
4227 **obj = wxGBPosition(-1,-1);
4228 return true;
4229 }
4230 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4231 }
4232
4233 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4234 {
4235 if (source == Py_None) {
4236 **obj = wxGBSpan(-1,-1);
4237 return true;
4238 }
4239 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4240 }
4241
4242
4243 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4244 wxGBPosition temp, *obj = &temp;
4245 if ( other == Py_None ) return false;
4246 if ( ! wxGBPosition_helper(other, &obj) ) {
4247 PyErr_Clear();
4248 return false;
4249 }
4250 return self->operator==(*obj);
4251 }
4252 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4253 wxGBPosition temp, *obj = &temp;
4254 if ( other == Py_None ) return true;
4255 if ( ! wxGBPosition_helper(other, &obj)) {
4256 PyErr_Clear();
4257 return true;
4258 }
4259 return self->operator!=(*obj);
4260 }
4261 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4262 self->SetRow(row);
4263 self->SetCol(col);
4264 }
4265 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 PyObject* tup = PyTuple_New(2);
4268 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4269 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4270 wxPyEndBlockThreads(blocked);
4271 return tup;
4272 }
4273 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4274 wxGBSpan temp, *obj = &temp;
4275 if ( other == Py_None ) return false;
4276 if ( ! wxGBSpan_helper(other, &obj) ) {
4277 PyErr_Clear();
4278 return false;
4279 }
4280 return self->operator==(*obj);
4281 }
4282 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4283 wxGBSpan temp, *obj = &temp;
4284 if ( other == Py_None ) return true;
4285 if ( ! wxGBSpan_helper(other, &obj)) {
4286 PyErr_Clear();
4287 return true;
4288 }
4289 return self->operator!=(*obj);
4290 }
4291 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4292 self->SetRowspan(rowspan);
4293 self->SetColspan(colspan);
4294 }
4295 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4297 PyObject* tup = PyTuple_New(2);
4298 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4299 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4300 wxPyEndBlockThreads(blocked);
4301 return tup;
4302 }
4303 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4304 wxPyUserData* data = NULL;
4305 if ( userData ) {
4306 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4307 data = new wxPyUserData(userData);
4308 wxPyEndBlockThreads(blocked);
4309 }
4310 return new wxGBSizerItem(window, pos, span, flag, border, data);
4311 }
4312 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4313 wxPyUserData* data = NULL;
4314 if ( userData ) {
4315 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4316 data = new wxPyUserData(userData);
4317 wxPyEndBlockThreads(blocked);
4318 }
4319 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4320 }
4321 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4322 wxPyUserData* data = NULL;
4323 if ( userData ) {
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 data = new wxPyUserData(userData);
4326 wxPyEndBlockThreads(blocked);
4327 }
4328 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4329 }
4330 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4331 int row, col;
4332 self->GetEndPos(row, col);
4333 return wxGBPosition(row, col);
4334 }
4335 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4336
4337 wxPyUserData* data = NULL;
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4340 if ( userData && (info.window || info.sizer || info.gotSize) )
4341 data = new wxPyUserData(userData);
4342 if ( info.sizer )
4343 PyObject_SetAttrString(item,"thisown",Py_False);
4344 wxPyEndBlockThreads(blocked);
4345
4346 // Now call the real Add method if a valid item type was found
4347 if ( info.window )
4348 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4349 else if ( info.sizer )
4350 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4351 else if (info.gotSize)
4352 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4353 pos, span, flag, border, data);
4354 return NULL;
4355 }
4356
4357
4358 #ifdef __cplusplus
4359 extern "C" {
4360 #endif
4361 SWIGINTERN int EmptyString_set(PyObject *) {
4362 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4363 return 1;
4364 }
4365
4366
4367 SWIGINTERN PyObject *EmptyString_get(void) {
4368 PyObject *pyobj = 0;
4369
4370 {
4371 #if wxUSE_UNICODE
4372 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4373 #else
4374 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4375 #endif
4376 }
4377 return pyobj;
4378 }
4379
4380
4381 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4382 PyObject *resultobj = 0;
4383 wxObject *arg1 = (wxObject *) 0 ;
4384 wxString result;
4385 void *argp1 = 0 ;
4386 int res1 = 0 ;
4387 PyObject *swig_obj[1] ;
4388
4389 if (!args) SWIG_fail;
4390 swig_obj[0] = args;
4391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4392 if (!SWIG_IsOK(res1)) {
4393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4394 }
4395 arg1 = reinterpret_cast< wxObject * >(argp1);
4396 {
4397 PyThreadState* __tstate = wxPyBeginAllowThreads();
4398 result = wxObject_GetClassName(arg1);
4399 wxPyEndAllowThreads(__tstate);
4400 if (PyErr_Occurred()) SWIG_fail;
4401 }
4402 {
4403 #if wxUSE_UNICODE
4404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4405 #else
4406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4407 #endif
4408 }
4409 return resultobj;
4410 fail:
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416 PyObject *resultobj = 0;
4417 wxObject *arg1 = (wxObject *) 0 ;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4427 }
4428 arg1 = reinterpret_cast< wxObject * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 wxObject_Destroy(arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 resultobj = SWIG_Py_Void();
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4443 PyObject *obj;
4444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4445 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4446 return SWIG_Py_Void();
4447 }
4448
4449 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *resultobj = 0;
4451 wxSize *arg1 = (wxSize *) 0 ;
4452 int arg2 ;
4453 void *argp1 = 0 ;
4454 int res1 = 0 ;
4455 int val2 ;
4456 int ecode2 = 0 ;
4457 PyObject *swig_obj[2] ;
4458
4459 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4461 if (!SWIG_IsOK(res1)) {
4462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4463 }
4464 arg1 = reinterpret_cast< wxSize * >(argp1);
4465 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4466 if (!SWIG_IsOK(ecode2)) {
4467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4468 }
4469 arg2 = static_cast< int >(val2);
4470 if (arg1) (arg1)->x = arg2;
4471
4472 resultobj = SWIG_Py_Void();
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4480 PyObject *resultobj = 0;
4481 wxSize *arg1 = (wxSize *) 0 ;
4482 int result;
4483 void *argp1 = 0 ;
4484 int res1 = 0 ;
4485 PyObject *swig_obj[1] ;
4486
4487 if (!args) SWIG_fail;
4488 swig_obj[0] = args;
4489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4490 if (!SWIG_IsOK(res1)) {
4491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4492 }
4493 arg1 = reinterpret_cast< wxSize * >(argp1);
4494 result = (int) ((arg1)->x);
4495 resultobj = SWIG_From_int(static_cast< int >(result));
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4503 PyObject *resultobj = 0;
4504 wxSize *arg1 = (wxSize *) 0 ;
4505 int arg2 ;
4506 void *argp1 = 0 ;
4507 int res1 = 0 ;
4508 int val2 ;
4509 int ecode2 = 0 ;
4510 PyObject *swig_obj[2] ;
4511
4512 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4516 }
4517 arg1 = reinterpret_cast< wxSize * >(argp1);
4518 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4519 if (!SWIG_IsOK(ecode2)) {
4520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4521 }
4522 arg2 = static_cast< int >(val2);
4523 if (arg1) (arg1)->y = arg2;
4524
4525 resultobj = SWIG_Py_Void();
4526 return resultobj;
4527 fail:
4528 return NULL;
4529 }
4530
4531
4532 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4533 PyObject *resultobj = 0;
4534 wxSize *arg1 = (wxSize *) 0 ;
4535 int result;
4536 void *argp1 = 0 ;
4537 int res1 = 0 ;
4538 PyObject *swig_obj[1] ;
4539
4540 if (!args) SWIG_fail;
4541 swig_obj[0] = args;
4542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4543 if (!SWIG_IsOK(res1)) {
4544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4545 }
4546 arg1 = reinterpret_cast< wxSize * >(argp1);
4547 result = (int) ((arg1)->y);
4548 resultobj = SWIG_From_int(static_cast< int >(result));
4549 return resultobj;
4550 fail:
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 int arg1 = (int) 0 ;
4558 int arg2 = (int) 0 ;
4559 wxSize *result = 0 ;
4560 int val1 ;
4561 int ecode1 = 0 ;
4562 int val2 ;
4563 int ecode2 = 0 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char * kwnames[] = {
4567 (char *) "w",(char *) "h", NULL
4568 };
4569
4570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4571 if (obj0) {
4572 ecode1 = SWIG_AsVal_int(obj0, &val1);
4573 if (!SWIG_IsOK(ecode1)) {
4574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4575 }
4576 arg1 = static_cast< int >(val1);
4577 }
4578 if (obj1) {
4579 ecode2 = SWIG_AsVal_int(obj1, &val2);
4580 if (!SWIG_IsOK(ecode2)) {
4581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4582 }
4583 arg2 = static_cast< int >(val2);
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (wxSize *)new wxSize(arg1,arg2);
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 void *argp1 = 0 ;
4602 int res1 = 0 ;
4603 PyObject *swig_obj[1] ;
4604
4605 if (!args) SWIG_fail;
4606 swig_obj[0] = args;
4607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4608 if (!SWIG_IsOK(res1)) {
4609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4610 }
4611 arg1 = reinterpret_cast< wxSize * >(argp1);
4612 {
4613 PyThreadState* __tstate = wxPyBeginAllowThreads();
4614 delete arg1;
4615
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_Py_Void();
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj = 0;
4628 wxSize *arg1 = (wxSize *) 0 ;
4629 PyObject *arg2 = (PyObject *) 0 ;
4630 bool result;
4631 void *argp1 = 0 ;
4632 int res1 = 0 ;
4633 PyObject * obj0 = 0 ;
4634 PyObject * obj1 = 0 ;
4635 char * kwnames[] = {
4636 (char *) "self",(char *) "other", NULL
4637 };
4638
4639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4643 }
4644 arg1 = reinterpret_cast< wxSize * >(argp1);
4645 arg2 = obj1;
4646 {
4647 result = (bool)wxSize___eq__(arg1,arg2);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 {
4651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4652 }
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 wxSize *arg1 = (wxSize *) 0 ;
4662 PyObject *arg2 = (PyObject *) 0 ;
4663 bool result;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "self",(char *) "other", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4674 if (!SWIG_IsOK(res1)) {
4675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4676 }
4677 arg1 = reinterpret_cast< wxSize * >(argp1);
4678 arg2 = obj1;
4679 {
4680 result = (bool)wxSize___ne__(arg1,arg2);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 wxSize *arg1 = (wxSize *) 0 ;
4695 wxSize *arg2 = 0 ;
4696 wxSize result;
4697 void *argp1 = 0 ;
4698 int res1 = 0 ;
4699 wxSize temp2 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "sz", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 {
4713 arg2 = &temp2;
4714 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4715 }
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (arg1)->operator +((wxSize const &)*arg2);
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
4729 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4730 PyObject *resultobj = 0;
4731 wxSize *arg1 = (wxSize *) 0 ;
4732 wxSize *arg2 = 0 ;
4733 wxSize result;
4734 void *argp1 = 0 ;
4735 int res1 = 0 ;
4736 wxSize temp2 ;
4737 PyObject * obj0 = 0 ;
4738 PyObject * obj1 = 0 ;
4739 char * kwnames[] = {
4740 (char *) "self",(char *) "sz", NULL
4741 };
4742
4743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4745 if (!SWIG_IsOK(res1)) {
4746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4747 }
4748 arg1 = reinterpret_cast< wxSize * >(argp1);
4749 {
4750 arg2 = &temp2;
4751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4752 }
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (arg1)->operator -((wxSize const &)*arg2);
4756 wxPyEndAllowThreads(__tstate);
4757 if (PyErr_Occurred()) SWIG_fail;
4758 }
4759 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4760 return resultobj;
4761 fail:
4762 return NULL;
4763 }
4764
4765
4766 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4767 PyObject *resultobj = 0;
4768 wxSize *arg1 = (wxSize *) 0 ;
4769 wxSize *arg2 = 0 ;
4770 void *argp1 = 0 ;
4771 int res1 = 0 ;
4772 wxSize temp2 ;
4773 PyObject * obj0 = 0 ;
4774 PyObject * obj1 = 0 ;
4775 char * kwnames[] = {
4776 (char *) "self",(char *) "sz", NULL
4777 };
4778
4779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4781 if (!SWIG_IsOK(res1)) {
4782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4783 }
4784 arg1 = reinterpret_cast< wxSize * >(argp1);
4785 {
4786 arg2 = &temp2;
4787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4788 }
4789 {
4790 PyThreadState* __tstate = wxPyBeginAllowThreads();
4791 (arg1)->IncTo((wxSize const &)*arg2);
4792 wxPyEndAllowThreads(__tstate);
4793 if (PyErr_Occurred()) SWIG_fail;
4794 }
4795 resultobj = SWIG_Py_Void();
4796 return resultobj;
4797 fail:
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4803 PyObject *resultobj = 0;
4804 wxSize *arg1 = (wxSize *) 0 ;
4805 wxSize *arg2 = 0 ;
4806 void *argp1 = 0 ;
4807 int res1 = 0 ;
4808 wxSize temp2 ;
4809 PyObject * obj0 = 0 ;
4810 PyObject * obj1 = 0 ;
4811 char * kwnames[] = {
4812 (char *) "self",(char *) "sz", NULL
4813 };
4814
4815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4817 if (!SWIG_IsOK(res1)) {
4818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4819 }
4820 arg1 = reinterpret_cast< wxSize * >(argp1);
4821 {
4822 arg2 = &temp2;
4823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 (arg1)->DecTo((wxSize const &)*arg2);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_Py_Void();
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj = 0;
4840 wxSize *arg1 = (wxSize *) 0 ;
4841 int arg2 ;
4842 int arg3 ;
4843 void *argp1 = 0 ;
4844 int res1 = 0 ;
4845 int val2 ;
4846 int ecode2 = 0 ;
4847 int val3 ;
4848 int ecode3 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 PyObject * obj2 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "w",(char *) "h", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 ecode2 = SWIG_AsVal_int(obj1, &val2);
4863 if (!SWIG_IsOK(ecode2)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4865 }
4866 arg2 = static_cast< int >(val2);
4867 ecode3 = SWIG_AsVal_int(obj2, &val3);
4868 if (!SWIG_IsOK(ecode3)) {
4869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4870 }
4871 arg3 = static_cast< int >(val3);
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 (arg1)->Set(arg2,arg3);
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_Py_Void();
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 wxSize *arg1 = (wxSize *) 0 ;
4888 int arg2 ;
4889 void *argp1 = 0 ;
4890 int res1 = 0 ;
4891 int val2 ;
4892 int ecode2 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 char * kwnames[] = {
4896 (char *) "self",(char *) "w", NULL
4897 };
4898
4899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4901 if (!SWIG_IsOK(res1)) {
4902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4903 }
4904 arg1 = reinterpret_cast< wxSize * >(argp1);
4905 ecode2 = SWIG_AsVal_int(obj1, &val2);
4906 if (!SWIG_IsOK(ecode2)) {
4907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4908 }
4909 arg2 = static_cast< int >(val2);
4910 {
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 (arg1)->SetWidth(arg2);
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_Py_Void();
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj = 0;
4925 wxSize *arg1 = (wxSize *) 0 ;
4926 int arg2 ;
4927 void *argp1 = 0 ;
4928 int res1 = 0 ;
4929 int val2 ;
4930 int ecode2 = 0 ;
4931 PyObject * obj0 = 0 ;
4932 PyObject * obj1 = 0 ;
4933 char * kwnames[] = {
4934 (char *) "self",(char *) "h", NULL
4935 };
4936
4937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4939 if (!SWIG_IsOK(res1)) {
4940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4941 }
4942 arg1 = reinterpret_cast< wxSize * >(argp1);
4943 ecode2 = SWIG_AsVal_int(obj1, &val2);
4944 if (!SWIG_IsOK(ecode2)) {
4945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4946 }
4947 arg2 = static_cast< int >(val2);
4948 {
4949 PyThreadState* __tstate = wxPyBeginAllowThreads();
4950 (arg1)->SetHeight(arg2);
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_Py_Void();
4955 return resultobj;
4956 fail:
4957 return NULL;
4958 }
4959
4960
4961 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4962 PyObject *resultobj = 0;
4963 wxSize *arg1 = (wxSize *) 0 ;
4964 int result;
4965 void *argp1 = 0 ;
4966 int res1 = 0 ;
4967 PyObject *swig_obj[1] ;
4968
4969 if (!args) SWIG_fail;
4970 swig_obj[0] = args;
4971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4972 if (!SWIG_IsOK(res1)) {
4973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4974 }
4975 arg1 = reinterpret_cast< wxSize * >(argp1);
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (int)((wxSize const *)arg1)->GetWidth();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 resultobj = SWIG_From_int(static_cast< int >(result));
4983 return resultobj;
4984 fail:
4985 return NULL;
4986 }
4987
4988
4989 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4990 PyObject *resultobj = 0;
4991 wxSize *arg1 = (wxSize *) 0 ;
4992 int result;
4993 void *argp1 = 0 ;
4994 int res1 = 0 ;
4995 PyObject *swig_obj[1] ;
4996
4997 if (!args) SWIG_fail;
4998 swig_obj[0] = args;
4999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5002 }
5003 arg1 = reinterpret_cast< wxSize * >(argp1);
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = (int)((wxSize const *)arg1)->GetHeight();
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_From_int(static_cast< int >(result));
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5018 PyObject *resultobj = 0;
5019 wxSize *arg1 = (wxSize *) 0 ;
5020 bool result;
5021 void *argp1 = 0 ;
5022 int res1 = 0 ;
5023 PyObject *swig_obj[1] ;
5024
5025 if (!args) SWIG_fail;
5026 swig_obj[0] = args;
5027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5028 if (!SWIG_IsOK(res1)) {
5029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5030 }
5031 arg1 = reinterpret_cast< wxSize * >(argp1);
5032 {
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 {
5039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5040 }
5041 return resultobj;
5042 fail:
5043 return NULL;
5044 }
5045
5046
5047 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj = 0;
5049 wxSize *arg1 = (wxSize *) 0 ;
5050 wxSize *arg2 = 0 ;
5051 void *argp1 = 0 ;
5052 int res1 = 0 ;
5053 wxSize temp2 ;
5054 PyObject * obj0 = 0 ;
5055 PyObject * obj1 = 0 ;
5056 char * kwnames[] = {
5057 (char *) "self",(char *) "size", NULL
5058 };
5059
5060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5062 if (!SWIG_IsOK(res1)) {
5063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5064 }
5065 arg1 = reinterpret_cast< wxSize * >(argp1);
5066 {
5067 arg2 = &temp2;
5068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5069 }
5070 {
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 (arg1)->SetDefaults((wxSize const &)*arg2);
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_Py_Void();
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5084 PyObject *resultobj = 0;
5085 wxSize *arg1 = (wxSize *) 0 ;
5086 PyObject *result = 0 ;
5087 void *argp1 = 0 ;
5088 int res1 = 0 ;
5089 PyObject *swig_obj[1] ;
5090
5091 if (!args) SWIG_fail;
5092 swig_obj[0] = args;
5093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5094 if (!SWIG_IsOK(res1)) {
5095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5096 }
5097 arg1 = reinterpret_cast< wxSize * >(argp1);
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 result = (PyObject *)wxSize_Get(arg1);
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = result;
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5112 PyObject *obj;
5113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5114 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5115 return SWIG_Py_Void();
5116 }
5117
5118 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 return SWIG_Python_InitShadowInstance(args);
5120 }
5121
5122 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5123 PyObject *resultobj = 0;
5124 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5125 double arg2 ;
5126 void *argp1 = 0 ;
5127 int res1 = 0 ;
5128 double val2 ;
5129 int ecode2 = 0 ;
5130 PyObject *swig_obj[2] ;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5134 if (!SWIG_IsOK(res1)) {
5135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5136 }
5137 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5138 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5139 if (!SWIG_IsOK(ecode2)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5141 }
5142 arg2 = static_cast< double >(val2);
5143 if (arg1) (arg1)->x = arg2;
5144
5145 resultobj = SWIG_Py_Void();
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5153 PyObject *resultobj = 0;
5154 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5155 double result;
5156 void *argp1 = 0 ;
5157 int res1 = 0 ;
5158 PyObject *swig_obj[1] ;
5159
5160 if (!args) SWIG_fail;
5161 swig_obj[0] = args;
5162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5163 if (!SWIG_IsOK(res1)) {
5164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5165 }
5166 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5167 result = (double) ((arg1)->x);
5168 resultobj = SWIG_From_double(static_cast< double >(result));
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *resultobj = 0;
5177 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5178 double arg2 ;
5179 void *argp1 = 0 ;
5180 int res1 = 0 ;
5181 double val2 ;
5182 int ecode2 = 0 ;
5183 PyObject *swig_obj[2] ;
5184
5185 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5189 }
5190 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5191 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5192 if (!SWIG_IsOK(ecode2)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5194 }
5195 arg2 = static_cast< double >(val2);
5196 if (arg1) (arg1)->y = arg2;
5197
5198 resultobj = SWIG_Py_Void();
5199 return resultobj;
5200 fail:
5201 return NULL;
5202 }
5203
5204
5205 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5206 PyObject *resultobj = 0;
5207 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5208 double result;
5209 void *argp1 = 0 ;
5210 int res1 = 0 ;
5211 PyObject *swig_obj[1] ;
5212
5213 if (!args) SWIG_fail;
5214 swig_obj[0] = args;
5215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5216 if (!SWIG_IsOK(res1)) {
5217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5218 }
5219 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5220 result = (double) ((arg1)->y);
5221 resultobj = SWIG_From_double(static_cast< double >(result));
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj = 0;
5230 double arg1 = (double) 0.0 ;
5231 double arg2 = (double) 0.0 ;
5232 wxRealPoint *result = 0 ;
5233 double val1 ;
5234 int ecode1 = 0 ;
5235 double val2 ;
5236 int ecode2 = 0 ;
5237 PyObject * obj0 = 0 ;
5238 PyObject * obj1 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "x",(char *) "y", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5244 if (obj0) {
5245 ecode1 = SWIG_AsVal_double(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5248 }
5249 arg1 = static_cast< double >(val1);
5250 }
5251 if (obj1) {
5252 ecode2 = SWIG_AsVal_double(obj1, &val2);
5253 if (!SWIG_IsOK(ecode2)) {
5254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5255 }
5256 arg2 = static_cast< double >(val2);
5257 }
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5272 PyObject *resultobj = 0;
5273 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5274 void *argp1 = 0 ;
5275 int res1 = 0 ;
5276 PyObject *swig_obj[1] ;
5277
5278 if (!args) SWIG_fail;
5279 swig_obj[0] = args;
5280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5281 if (!SWIG_IsOK(res1)) {
5282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5283 }
5284 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 delete arg1;
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 resultobj = SWIG_Py_Void();
5293 return resultobj;
5294 fail:
5295 return NULL;
5296 }
5297
5298
5299 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5300 PyObject *resultobj = 0;
5301 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5302 PyObject *arg2 = (PyObject *) 0 ;
5303 bool result;
5304 void *argp1 = 0 ;
5305 int res1 = 0 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char * kwnames[] = {
5309 (char *) "self",(char *) "other", NULL
5310 };
5311
5312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5316 }
5317 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5318 arg2 = obj1;
5319 {
5320 result = (bool)wxRealPoint___eq__(arg1,arg2);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj = 0;
5334 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5335 PyObject *arg2 = (PyObject *) 0 ;
5336 bool result;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject * obj0 = 0 ;
5340 PyObject * obj1 = 0 ;
5341 char * kwnames[] = {
5342 (char *) "self",(char *) "other", NULL
5343 };
5344
5345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5347 if (!SWIG_IsOK(res1)) {
5348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5349 }
5350 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5351 arg2 = obj1;
5352 {
5353 result = (bool)wxRealPoint___ne__(arg1,arg2);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj = 0;
5367 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5368 wxRealPoint *arg2 = 0 ;
5369 wxRealPoint result;
5370 void *argp1 = 0 ;
5371 int res1 = 0 ;
5372 wxRealPoint temp2 ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 char * kwnames[] = {
5376 (char *) "self",(char *) "pt", NULL
5377 };
5378
5379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5381 if (!SWIG_IsOK(res1)) {
5382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5383 }
5384 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5385 {
5386 arg2 = &temp2;
5387 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5388 }
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 wxRealPoint *arg2 = 0 ;
5406 wxRealPoint result;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 wxRealPoint temp2 ;
5410 PyObject * obj0 = 0 ;
5411 PyObject * obj1 = 0 ;
5412 char * kwnames[] = {
5413 (char *) "self",(char *) "pt", NULL
5414 };
5415
5416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5418 if (!SWIG_IsOK(res1)) {
5419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5420 }
5421 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5422 {
5423 arg2 = &temp2;
5424 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5425 }
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5429 wxPyEndAllowThreads(__tstate);
5430 if (PyErr_Occurred()) SWIG_fail;
5431 }
5432 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5442 double arg2 ;
5443 double arg3 ;
5444 void *argp1 = 0 ;
5445 int res1 = 0 ;
5446 double val2 ;
5447 int ecode2 = 0 ;
5448 double val3 ;
5449 int ecode3 = 0 ;
5450 PyObject * obj0 = 0 ;
5451 PyObject * obj1 = 0 ;
5452 PyObject * obj2 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "x",(char *) "y", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 ecode2 = SWIG_AsVal_double(obj1, &val2);
5464 if (!SWIG_IsOK(ecode2)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5466 }
5467 arg2 = static_cast< double >(val2);
5468 ecode3 = SWIG_AsVal_double(obj2, &val3);
5469 if (!SWIG_IsOK(ecode3)) {
5470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5471 }
5472 arg3 = static_cast< double >(val3);
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 wxRealPoint_Set(arg1,arg2,arg3);
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 resultobj = SWIG_Py_Void();
5480 return resultobj;
5481 fail:
5482 return NULL;
5483 }
5484
5485
5486 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 PyObject *resultobj = 0;
5488 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5489 PyObject *result = 0 ;
5490 void *argp1 = 0 ;
5491 int res1 = 0 ;
5492 PyObject *swig_obj[1] ;
5493
5494 if (!args) SWIG_fail;
5495 swig_obj[0] = args;
5496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (PyObject *)wxRealPoint_Get(arg1);
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 resultobj = result;
5508 return resultobj;
5509 fail:
5510 return NULL;
5511 }
5512
5513
5514 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5515 PyObject *obj;
5516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5517 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5518 return SWIG_Py_Void();
5519 }
5520
5521 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 return SWIG_Python_InitShadowInstance(args);
5523 }
5524
5525 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *resultobj = 0;
5527 wxPoint *arg1 = (wxPoint *) 0 ;
5528 int arg2 ;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 int val2 ;
5532 int ecode2 = 0 ;
5533 PyObject *swig_obj[2] ;
5534
5535 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5544 }
5545 arg2 = static_cast< int >(val2);
5546 if (arg1) (arg1)->x = arg2;
5547
5548 resultobj = SWIG_Py_Void();
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxPoint *arg1 = (wxPoint *) 0 ;
5558 int result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject *swig_obj[1] ;
5562
5563 if (!args) SWIG_fail;
5564 swig_obj[0] = args;
5565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5568 }
5569 arg1 = reinterpret_cast< wxPoint * >(argp1);
5570 result = (int) ((arg1)->x);
5571 resultobj = SWIG_From_int(static_cast< int >(result));
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *resultobj = 0;
5580 wxPoint *arg1 = (wxPoint *) 0 ;
5581 int arg2 ;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 int val2 ;
5585 int ecode2 = 0 ;
5586 PyObject *swig_obj[2] ;
5587
5588 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5590 if (!SWIG_IsOK(res1)) {
5591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5592 }
5593 arg1 = reinterpret_cast< wxPoint * >(argp1);
5594 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5595 if (!SWIG_IsOK(ecode2)) {
5596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5597 }
5598 arg2 = static_cast< int >(val2);
5599 if (arg1) (arg1)->y = arg2;
5600
5601 resultobj = SWIG_Py_Void();
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5609 PyObject *resultobj = 0;
5610 wxPoint *arg1 = (wxPoint *) 0 ;
5611 int result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 PyObject *swig_obj[1] ;
5615
5616 if (!args) SWIG_fail;
5617 swig_obj[0] = args;
5618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5619 if (!SWIG_IsOK(res1)) {
5620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5621 }
5622 arg1 = reinterpret_cast< wxPoint * >(argp1);
5623 result = (int) ((arg1)->y);
5624 resultobj = SWIG_From_int(static_cast< int >(result));
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj = 0;
5633 int arg1 = (int) 0 ;
5634 int arg2 = (int) 0 ;
5635 wxPoint *result = 0 ;
5636 int val1 ;
5637 int ecode1 = 0 ;
5638 int val2 ;
5639 int ecode2 = 0 ;
5640 PyObject * obj0 = 0 ;
5641 PyObject * obj1 = 0 ;
5642 char * kwnames[] = {
5643 (char *) "x",(char *) "y", NULL
5644 };
5645
5646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5647 if (obj0) {
5648 ecode1 = SWIG_AsVal_int(obj0, &val1);
5649 if (!SWIG_IsOK(ecode1)) {
5650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5651 }
5652 arg1 = static_cast< int >(val1);
5653 }
5654 if (obj1) {
5655 ecode2 = SWIG_AsVal_int(obj1, &val2);
5656 if (!SWIG_IsOK(ecode2)) {
5657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5658 }
5659 arg2 = static_cast< int >(val2);
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (wxPoint *)new wxPoint(arg1,arg2);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675 PyObject *resultobj = 0;
5676 wxPoint *arg1 = (wxPoint *) 0 ;
5677 void *argp1 = 0 ;
5678 int res1 = 0 ;
5679 PyObject *swig_obj[1] ;
5680
5681 if (!args) SWIG_fail;
5682 swig_obj[0] = args;
5683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5684 if (!SWIG_IsOK(res1)) {
5685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5686 }
5687 arg1 = reinterpret_cast< wxPoint * >(argp1);
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 delete arg1;
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj = 0;
5704 wxPoint *arg1 = (wxPoint *) 0 ;
5705 PyObject *arg2 = (PyObject *) 0 ;
5706 bool result;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject * obj0 = 0 ;
5710 PyObject * obj1 = 0 ;
5711 char * kwnames[] = {
5712 (char *) "self",(char *) "other", NULL
5713 };
5714
5715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5717 if (!SWIG_IsOK(res1)) {
5718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5719 }
5720 arg1 = reinterpret_cast< wxPoint * >(argp1);
5721 arg2 = obj1;
5722 {
5723 result = (bool)wxPoint___eq__(arg1,arg2);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 {
5727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5728 }
5729 return resultobj;
5730 fail:
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 PyObject *arg2 = (PyObject *) 0 ;
5739 bool result;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 char * kwnames[] = {
5745 (char *) "self",(char *) "other", NULL
5746 };
5747
5748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5750 if (!SWIG_IsOK(res1)) {
5751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5752 }
5753 arg1 = reinterpret_cast< wxPoint * >(argp1);
5754 arg2 = obj1;
5755 {
5756 result = (bool)wxPoint___ne__(arg1,arg2);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 {
5760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5761 }
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = 0;
5770 wxPoint *arg1 = (wxPoint *) 0 ;
5771 wxPoint *arg2 = 0 ;
5772 wxPoint result;
5773 void *argp1 = 0 ;
5774 int res1 = 0 ;
5775 wxPoint temp2 ;
5776 PyObject * obj0 = 0 ;
5777 PyObject * obj1 = 0 ;
5778 char * kwnames[] = {
5779 (char *) "self",(char *) "pt", NULL
5780 };
5781
5782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5784 if (!SWIG_IsOK(res1)) {
5785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5786 }
5787 arg1 = reinterpret_cast< wxPoint * >(argp1);
5788 {
5789 arg2 = &temp2;
5790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5791 }
5792 {
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 result = (arg1)->operator +((wxPoint const &)*arg2);
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj = 0;
5807 wxPoint *arg1 = (wxPoint *) 0 ;
5808 wxPoint *arg2 = 0 ;
5809 wxPoint result;
5810 void *argp1 = 0 ;
5811 int res1 = 0 ;
5812 wxPoint temp2 ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 char * kwnames[] = {
5816 (char *) "self",(char *) "pt", NULL
5817 };
5818
5819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5821 if (!SWIG_IsOK(res1)) {
5822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5823 }
5824 arg1 = reinterpret_cast< wxPoint * >(argp1);
5825 {
5826 arg2 = &temp2;
5827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5828 }
5829 {
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 result = (arg1)->operator -((wxPoint const &)*arg2);
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 wxPoint *arg1 = (wxPoint *) 0 ;
5845 wxPoint *arg2 = 0 ;
5846 wxPoint *result = 0 ;
5847 void *argp1 = 0 ;
5848 int res1 = 0 ;
5849 wxPoint temp2 ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 char * kwnames[] = {
5853 (char *) "self",(char *) "pt", NULL
5854 };
5855
5856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5860 }
5861 arg1 = reinterpret_cast< wxPoint * >(argp1);
5862 {
5863 arg2 = &temp2;
5864 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5865 }
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 {
5869 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5870 result = (wxPoint *) &_result_ref;
5871 }
5872 wxPyEndAllowThreads(__tstate);
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj = 0;
5884 wxPoint *arg1 = (wxPoint *) 0 ;
5885 wxPoint *arg2 = 0 ;
5886 wxPoint *result = 0 ;
5887 void *argp1 = 0 ;
5888 int res1 = 0 ;
5889 wxPoint temp2 ;
5890 PyObject * obj0 = 0 ;
5891 PyObject * obj1 = 0 ;
5892 char * kwnames[] = {
5893 (char *) "self",(char *) "pt", NULL
5894 };
5895
5896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5898 if (!SWIG_IsOK(res1)) {
5899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5900 }
5901 arg1 = reinterpret_cast< wxPoint * >(argp1);
5902 {
5903 arg2 = &temp2;
5904 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5905 }
5906 {
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 {
5909 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5910 result = (wxPoint *) &_result_ref;
5911 }
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5916 return resultobj;
5917 fail:
5918 return NULL;
5919 }
5920
5921
5922 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5923 PyObject *resultobj = 0;
5924 wxPoint *arg1 = (wxPoint *) 0 ;
5925 long arg2 ;
5926 long arg3 ;
5927 void *argp1 = 0 ;
5928 int res1 = 0 ;
5929 long val2 ;
5930 int ecode2 = 0 ;
5931 long val3 ;
5932 int ecode3 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 char * kwnames[] = {
5937 (char *) "self",(char *) "x",(char *) "y", NULL
5938 };
5939
5940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5942 if (!SWIG_IsOK(res1)) {
5943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5944 }
5945 arg1 = reinterpret_cast< wxPoint * >(argp1);
5946 ecode2 = SWIG_AsVal_long(obj1, &val2);
5947 if (!SWIG_IsOK(ecode2)) {
5948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5949 }
5950 arg2 = static_cast< long >(val2);
5951 ecode3 = SWIG_AsVal_long(obj2, &val3);
5952 if (!SWIG_IsOK(ecode3)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5954 }
5955 arg3 = static_cast< long >(val3);
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 wxPoint_Set(arg1,arg2,arg3);
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 resultobj = SWIG_Py_Void();
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5970 PyObject *resultobj = 0;
5971 wxPoint *arg1 = (wxPoint *) 0 ;
5972 PyObject *result = 0 ;
5973 void *argp1 = 0 ;
5974 int res1 = 0 ;
5975 PyObject *swig_obj[1] ;
5976
5977 if (!args) SWIG_fail;
5978 swig_obj[0] = args;
5979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = (PyObject *)wxPoint_Get(arg1);
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = result;
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5998 PyObject *obj;
5999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6001 return SWIG_Py_Void();
6002 }
6003
6004 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6005 return SWIG_Python_InitShadowInstance(args);
6006 }
6007
6008 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj = 0;
6010 int arg1 = (int) 0 ;
6011 int arg2 = (int) 0 ;
6012 int arg3 = (int) 0 ;
6013 int arg4 = (int) 0 ;
6014 wxRect *result = 0 ;
6015 int val1 ;
6016 int ecode1 = 0 ;
6017 int val2 ;
6018 int ecode2 = 0 ;
6019 int val3 ;
6020 int ecode3 = 0 ;
6021 int val4 ;
6022 int ecode4 = 0 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 PyObject * obj2 = 0 ;
6026 PyObject * obj3 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6032 if (obj0) {
6033 ecode1 = SWIG_AsVal_int(obj0, &val1);
6034 if (!SWIG_IsOK(ecode1)) {
6035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6036 }
6037 arg1 = static_cast< int >(val1);
6038 }
6039 if (obj1) {
6040 ecode2 = SWIG_AsVal_int(obj1, &val2);
6041 if (!SWIG_IsOK(ecode2)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6043 }
6044 arg2 = static_cast< int >(val2);
6045 }
6046 if (obj2) {
6047 ecode3 = SWIG_AsVal_int(obj2, &val3);
6048 if (!SWIG_IsOK(ecode3)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6050 }
6051 arg3 = static_cast< int >(val3);
6052 }
6053 if (obj3) {
6054 ecode4 = SWIG_AsVal_int(obj3, &val4);
6055 if (!SWIG_IsOK(ecode4)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6057 }
6058 arg4 = static_cast< int >(val4);
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj = 0;
6075 wxPoint *arg1 = 0 ;
6076 wxPoint *arg2 = 0 ;
6077 wxRect *result = 0 ;
6078 wxPoint temp1 ;
6079 wxPoint temp2 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char * kwnames[] = {
6083 (char *) "topLeft",(char *) "bottomRight", NULL
6084 };
6085
6086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6087 {
6088 arg1 = &temp1;
6089 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6090 }
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj = 0;
6110 wxPoint *arg1 = 0 ;
6111 wxSize *arg2 = 0 ;
6112 wxRect *result = 0 ;
6113 wxPoint temp1 ;
6114 wxSize temp2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char * kwnames[] = {
6118 (char *) "pos",(char *) "size", NULL
6119 };
6120
6121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6122 {
6123 arg1 = &temp1;
6124 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6125 }
6126 {
6127 arg2 = &temp2;
6128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6129 }
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6144 PyObject *resultobj = 0;
6145 wxSize *arg1 = 0 ;
6146 wxRect *result = 0 ;
6147 wxSize temp1 ;
6148 PyObject * obj0 = 0 ;
6149 char * kwnames[] = {
6150 (char *) "size", NULL
6151 };
6152
6153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6154 {
6155 arg1 = &temp1;
6156 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6172 PyObject *resultobj = 0;
6173 wxRect *arg1 = (wxRect *) 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6183 }
6184 arg1 = reinterpret_cast< wxRect * >(argp1);
6185 {
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 delete arg1;
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 resultobj = SWIG_Py_Void();
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6200 PyObject *resultobj = 0;
6201 wxRect *arg1 = (wxRect *) 0 ;
6202 int result;
6203 void *argp1 = 0 ;
6204 int res1 = 0 ;
6205 PyObject *swig_obj[1] ;
6206
6207 if (!args) SWIG_fail;
6208 swig_obj[0] = args;
6209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6210 if (!SWIG_IsOK(res1)) {
6211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6212 }
6213 arg1 = reinterpret_cast< wxRect * >(argp1);
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 result = (int)((wxRect const *)arg1)->GetX();
6217 wxPyEndAllowThreads(__tstate);
6218 if (PyErr_Occurred()) SWIG_fail;
6219 }
6220 resultobj = SWIG_From_int(static_cast< int >(result));
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj = 0;
6229 wxRect *arg1 = (wxRect *) 0 ;
6230 int arg2 ;
6231 void *argp1 = 0 ;
6232 int res1 = 0 ;
6233 int val2 ;
6234 int ecode2 = 0 ;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char * kwnames[] = {
6238 (char *) "self",(char *) "x", NULL
6239 };
6240
6241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6243 if (!SWIG_IsOK(res1)) {
6244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6245 }
6246 arg1 = reinterpret_cast< wxRect * >(argp1);
6247 ecode2 = SWIG_AsVal_int(obj1, &val2);
6248 if (!SWIG_IsOK(ecode2)) {
6249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6250 }
6251 arg2 = static_cast< int >(val2);
6252 {
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 (arg1)->SetX(arg2);
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_Py_Void();
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6266 PyObject *resultobj = 0;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int result;
6269 void *argp1 = 0 ;
6270 int res1 = 0 ;
6271 PyObject *swig_obj[1] ;
6272
6273 if (!args) SWIG_fail;
6274 swig_obj[0] = args;
6275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6276 if (!SWIG_IsOK(res1)) {
6277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6278 }
6279 arg1 = reinterpret_cast< wxRect * >(argp1);
6280 {
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (int)(arg1)->GetY();
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 resultobj = SWIG_From_int(static_cast< int >(result));
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj = 0;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 int arg2 ;
6297 void *argp1 = 0 ;
6298 int res1 = 0 ;
6299 int val2 ;
6300 int ecode2 = 0 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 char * kwnames[] = {
6304 (char *) "self",(char *) "y", NULL
6305 };
6306
6307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6309 if (!SWIG_IsOK(res1)) {
6310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6311 }
6312 arg1 = reinterpret_cast< wxRect * >(argp1);
6313 ecode2 = SWIG_AsVal_int(obj1, &val2);
6314 if (!SWIG_IsOK(ecode2)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6316 }
6317 arg2 = static_cast< int >(val2);
6318 {
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 (arg1)->SetY(arg2);
6321 wxPyEndAllowThreads(__tstate);
6322 if (PyErr_Occurred()) SWIG_fail;
6323 }
6324 resultobj = SWIG_Py_Void();
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6332 PyObject *resultobj = 0;
6333 wxRect *arg1 = (wxRect *) 0 ;
6334 int result;
6335 void *argp1 = 0 ;
6336 int res1 = 0 ;
6337 PyObject *swig_obj[1] ;
6338
6339 if (!args) SWIG_fail;
6340 swig_obj[0] = args;
6341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6342 if (!SWIG_IsOK(res1)) {
6343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6344 }
6345 arg1 = reinterpret_cast< wxRect * >(argp1);
6346 {
6347 PyThreadState* __tstate = wxPyBeginAllowThreads();
6348 result = (int)((wxRect const *)arg1)->GetWidth();
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 resultobj = SWIG_From_int(static_cast< int >(result));
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj = 0;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 int arg2 ;
6363 void *argp1 = 0 ;
6364 int res1 = 0 ;
6365 int val2 ;
6366 int ecode2 = 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 char * kwnames[] = {
6370 (char *) "self",(char *) "w", NULL
6371 };
6372
6373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6375 if (!SWIG_IsOK(res1)) {
6376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6377 }
6378 arg1 = reinterpret_cast< wxRect * >(argp1);
6379 ecode2 = SWIG_AsVal_int(obj1, &val2);
6380 if (!SWIG_IsOK(ecode2)) {
6381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6382 }
6383 arg2 = static_cast< int >(val2);
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 (arg1)->SetWidth(arg2);
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 resultobj = SWIG_Py_Void();
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6398 PyObject *resultobj = 0;
6399 wxRect *arg1 = (wxRect *) 0 ;
6400 int result;
6401 void *argp1 = 0 ;
6402 int res1 = 0 ;
6403 PyObject *swig_obj[1] ;
6404
6405 if (!args) SWIG_fail;
6406 swig_obj[0] = args;
6407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6408 if (!SWIG_IsOK(res1)) {
6409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6410 }
6411 arg1 = reinterpret_cast< wxRect * >(argp1);
6412 {
6413 PyThreadState* __tstate = wxPyBeginAllowThreads();
6414 result = (int)((wxRect const *)arg1)->GetHeight();
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_From_int(static_cast< int >(result));
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj = 0;
6427 wxRect *arg1 = (wxRect *) 0 ;
6428 int arg2 ;
6429 void *argp1 = 0 ;
6430 int res1 = 0 ;
6431 int val2 ;
6432 int ecode2 = 0 ;
6433 PyObject * obj0 = 0 ;
6434 PyObject * obj1 = 0 ;
6435 char * kwnames[] = {
6436 (char *) "self",(char *) "h", NULL
6437 };
6438
6439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6441 if (!SWIG_IsOK(res1)) {
6442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6443 }
6444 arg1 = reinterpret_cast< wxRect * >(argp1);
6445 ecode2 = SWIG_AsVal_int(obj1, &val2);
6446 if (!SWIG_IsOK(ecode2)) {
6447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6448 }
6449 arg2 = static_cast< int >(val2);
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 (arg1)->SetHeight(arg2);
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_Py_Void();
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6464 PyObject *resultobj = 0;
6465 wxRect *arg1 = (wxRect *) 0 ;
6466 wxPoint result;
6467 void *argp1 = 0 ;
6468 int res1 = 0 ;
6469 PyObject *swig_obj[1] ;
6470
6471 if (!args) SWIG_fail;
6472 swig_obj[0] = args;
6473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6474 if (!SWIG_IsOK(res1)) {
6475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6476 }
6477 arg1 = reinterpret_cast< wxRect * >(argp1);
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = ((wxRect const *)arg1)->GetPosition();
6481 wxPyEndAllowThreads(__tstate);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6492 PyObject *resultobj = 0;
6493 wxRect *arg1 = (wxRect *) 0 ;
6494 wxPoint *arg2 = 0 ;
6495 void *argp1 = 0 ;
6496 int res1 = 0 ;
6497 wxPoint temp2 ;
6498 PyObject * obj0 = 0 ;
6499 PyObject * obj1 = 0 ;
6500 char * kwnames[] = {
6501 (char *) "self",(char *) "p", NULL
6502 };
6503
6504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6506 if (!SWIG_IsOK(res1)) {
6507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6508 }
6509 arg1 = reinterpret_cast< wxRect * >(argp1);
6510 {
6511 arg2 = &temp2;
6512 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6513 }
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 (arg1)->SetPosition((wxPoint const &)*arg2);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_Py_Void();
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528 PyObject *resultobj = 0;
6529 wxRect *arg1 = (wxRect *) 0 ;
6530 wxSize result;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 PyObject *swig_obj[1] ;
6534
6535 if (!args) SWIG_fail;
6536 swig_obj[0] = args;
6537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = ((wxRect const *)arg1)->GetSize();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxRect *arg1 = (wxRect *) 0 ;
6558 wxSize *arg2 = 0 ;
6559 void *argp1 = 0 ;
6560 int res1 = 0 ;
6561 wxSize temp2 ;
6562 PyObject * obj0 = 0 ;
6563 PyObject * obj1 = 0 ;
6564 char * kwnames[] = {
6565 (char *) "self",(char *) "s", NULL
6566 };
6567
6568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6570 if (!SWIG_IsOK(res1)) {
6571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6572 }
6573 arg1 = reinterpret_cast< wxRect * >(argp1);
6574 {
6575 arg2 = &temp2;
6576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6577 }
6578 {
6579 PyThreadState* __tstate = wxPyBeginAllowThreads();
6580 (arg1)->SetSize((wxSize const &)*arg2);
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 resultobj = SWIG_Py_Void();
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6592 PyObject *resultobj = 0;
6593 wxRect *arg1 = (wxRect *) 0 ;
6594 bool result;
6595 void *argp1 = 0 ;
6596 int res1 = 0 ;
6597 PyObject *swig_obj[1] ;
6598
6599 if (!args) SWIG_fail;
6600 swig_obj[0] = args;
6601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6602 if (!SWIG_IsOK(res1)) {
6603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6604 }
6605 arg1 = reinterpret_cast< wxRect * >(argp1);
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = (bool)((wxRect const *)arg1)->IsEmpty();
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 {
6613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6614 }
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint result;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 PyObject *swig_obj[1] ;
6628
6629 if (!args) SWIG_fail;
6630 swig_obj[0] = args;
6631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6632 if (!SWIG_IsOK(res1)) {
6633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6634 }
6635 arg1 = reinterpret_cast< wxRect * >(argp1);
6636 {
6637 PyThreadState* __tstate = wxPyBeginAllowThreads();
6638 result = ((wxRect const *)arg1)->GetTopLeft();
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj = 0;
6651 wxRect *arg1 = (wxRect *) 0 ;
6652 wxPoint *arg2 = 0 ;
6653 void *argp1 = 0 ;
6654 int res1 = 0 ;
6655 wxPoint temp2 ;
6656 PyObject * obj0 = 0 ;
6657 PyObject * obj1 = 0 ;
6658 char * kwnames[] = {
6659 (char *) "self",(char *) "p", NULL
6660 };
6661
6662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6664 if (!SWIG_IsOK(res1)) {
6665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6666 }
6667 arg1 = reinterpret_cast< wxRect * >(argp1);
6668 {
6669 arg2 = &temp2;
6670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6671 }
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_Py_Void();
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 wxPoint result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = ((wxRect const *)arg1)->GetBottomRight();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 wxPoint *arg2 = 0 ;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 wxPoint temp2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char * kwnames[] = {
6723 (char *) "self",(char *) "p", NULL
6724 };
6725
6726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 arg2 = &temp2;
6734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 resultobj = SWIG_Py_Void();
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6750 PyObject *resultobj = 0;
6751 wxRect *arg1 = (wxRect *) 0 ;
6752 int result;
6753 void *argp1 = 0 ;
6754 int res1 = 0 ;
6755 PyObject *swig_obj[1] ;
6756
6757 if (!args) SWIG_fail;
6758 swig_obj[0] = args;
6759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6760 if (!SWIG_IsOK(res1)) {
6761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6762 }
6763 arg1 = reinterpret_cast< wxRect * >(argp1);
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = (int)((wxRect const *)arg1)->GetLeft();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_From_int(static_cast< int >(result));
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 int result;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject *swig_obj[1] ;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 result = (int)((wxRect const *)arg1)->GetTop();
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 resultobj = SWIG_From_int(static_cast< int >(result));
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6806 PyObject *resultobj = 0;
6807 wxRect *arg1 = (wxRect *) 0 ;
6808 int result;
6809 void *argp1 = 0 ;
6810 int res1 = 0 ;
6811 PyObject *swig_obj[1] ;
6812
6813 if (!args) SWIG_fail;
6814 swig_obj[0] = args;
6815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6816 if (!SWIG_IsOK(res1)) {
6817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6818 }
6819 arg1 = reinterpret_cast< wxRect * >(argp1);
6820 {
6821 PyThreadState* __tstate = wxPyBeginAllowThreads();
6822 result = (int)((wxRect const *)arg1)->GetBottom();
6823 wxPyEndAllowThreads(__tstate);
6824 if (PyErr_Occurred()) SWIG_fail;
6825 }
6826 resultobj = SWIG_From_int(static_cast< int >(result));
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6834 PyObject *resultobj = 0;
6835 wxRect *arg1 = (wxRect *) 0 ;
6836 int result;
6837 void *argp1 = 0 ;
6838 int res1 = 0 ;
6839 PyObject *swig_obj[1] ;
6840
6841 if (!args) SWIG_fail;
6842 swig_obj[0] = args;
6843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6844 if (!SWIG_IsOK(res1)) {
6845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6846 }
6847 arg1 = reinterpret_cast< wxRect * >(argp1);
6848 {
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (int)((wxRect const *)arg1)->GetRight();
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 resultobj = SWIG_From_int(static_cast< int >(result));
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj = 0;
6863 wxRect *arg1 = (wxRect *) 0 ;
6864 int arg2 ;
6865 void *argp1 = 0 ;
6866 int res1 = 0 ;
6867 int val2 ;
6868 int ecode2 = 0 ;
6869 PyObject * obj0 = 0 ;
6870 PyObject * obj1 = 0 ;
6871 char * kwnames[] = {
6872 (char *) "self",(char *) "left", NULL
6873 };
6874
6875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6877 if (!SWIG_IsOK(res1)) {
6878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6879 }
6880 arg1 = reinterpret_cast< wxRect * >(argp1);
6881 ecode2 = SWIG_AsVal_int(obj1, &val2);
6882 if (!SWIG_IsOK(ecode2)) {
6883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6884 }
6885 arg2 = static_cast< int >(val2);
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 (arg1)->SetLeft(arg2);
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 resultobj = SWIG_Py_Void();
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj = 0;
6901 wxRect *arg1 = (wxRect *) 0 ;
6902 int arg2 ;
6903 void *argp1 = 0 ;
6904 int res1 = 0 ;
6905 int val2 ;
6906 int ecode2 = 0 ;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char * kwnames[] = {
6910 (char *) "self",(char *) "right", NULL
6911 };
6912
6913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 ecode2 = SWIG_AsVal_int(obj1, &val2);
6920 if (!SWIG_IsOK(ecode2)) {
6921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6922 }
6923 arg2 = static_cast< int >(val2);
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 (arg1)->SetRight(arg2);
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_Py_Void();
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj = 0;
6939 wxRect *arg1 = (wxRect *) 0 ;
6940 int arg2 ;
6941 void *argp1 = 0 ;
6942 int res1 = 0 ;
6943 int val2 ;
6944 int ecode2 = 0 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char * kwnames[] = {
6948 (char *) "self",(char *) "top", NULL
6949 };
6950
6951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6953 if (!SWIG_IsOK(res1)) {
6954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6955 }
6956 arg1 = reinterpret_cast< wxRect * >(argp1);
6957 ecode2 = SWIG_AsVal_int(obj1, &val2);
6958 if (!SWIG_IsOK(ecode2)) {
6959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6960 }
6961 arg2 = static_cast< int >(val2);
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 (arg1)->SetTop(arg2);
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_Py_Void();
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj = 0;
6977 wxRect *arg1 = (wxRect *) 0 ;
6978 int arg2 ;
6979 void *argp1 = 0 ;
6980 int res1 = 0 ;
6981 int val2 ;
6982 int ecode2 = 0 ;
6983 PyObject * obj0 = 0 ;
6984 PyObject * obj1 = 0 ;
6985 char * kwnames[] = {
6986 (char *) "self",(char *) "bottom", NULL
6987 };
6988
6989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6991 if (!SWIG_IsOK(res1)) {
6992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6993 }
6994 arg1 = reinterpret_cast< wxRect * >(argp1);
6995 ecode2 = SWIG_AsVal_int(obj1, &val2);
6996 if (!SWIG_IsOK(ecode2)) {
6997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6998 }
6999 arg2 = static_cast< int >(val2);
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 (arg1)->SetBottom(arg2);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = 0;
7015 wxRect *arg1 = (wxRect *) 0 ;
7016 int arg2 ;
7017 int arg3 ;
7018 wxRect *result = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 int val3 ;
7024 int ecode3 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 PyObject * obj1 = 0 ;
7027 PyObject * obj2 = 0 ;
7028 char * kwnames[] = {
7029 (char *) "self",(char *) "dx",(char *) "dy", NULL
7030 };
7031
7032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 ecode2 = SWIG_AsVal_int(obj1, &val2);
7039 if (!SWIG_IsOK(ecode2)) {
7040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7041 }
7042 arg2 = static_cast< int >(val2);
7043 ecode3 = SWIG_AsVal_int(obj2, &val3);
7044 if (!SWIG_IsOK(ecode3)) {
7045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7046 }
7047 arg3 = static_cast< int >(val3);
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 {
7051 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7052 result = (wxRect *) &_result_ref;
7053 }
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int arg2 ;
7068 int arg3 ;
7069 wxRect *result = 0 ;
7070 void *argp1 = 0 ;
7071 int res1 = 0 ;
7072 int val2 ;
7073 int ecode2 = 0 ;
7074 int val3 ;
7075 int ecode3 = 0 ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 PyObject * obj2 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "dx",(char *) "dy", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7087 }
7088 arg1 = reinterpret_cast< wxRect * >(argp1);
7089 ecode2 = SWIG_AsVal_int(obj1, &val2);
7090 if (!SWIG_IsOK(ecode2)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7092 }
7093 arg2 = static_cast< int >(val2);
7094 ecode3 = SWIG_AsVal_int(obj2, &val3);
7095 if (!SWIG_IsOK(ecode3)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7097 }
7098 arg3 = static_cast< int >(val3);
7099 {
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 {
7102 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7103 result = (wxRect *) &_result_ref;
7104 }
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7116 PyObject *resultobj = 0;
7117 wxRect *arg1 = (wxRect *) 0 ;
7118 int arg2 ;
7119 int arg3 ;
7120 void *argp1 = 0 ;
7121 int res1 = 0 ;
7122 int val2 ;
7123 int ecode2 = 0 ;
7124 int val3 ;
7125 int ecode3 = 0 ;
7126 PyObject * obj0 = 0 ;
7127 PyObject * obj1 = 0 ;
7128 PyObject * obj2 = 0 ;
7129 char * kwnames[] = {
7130 (char *) "self",(char *) "dx",(char *) "dy", NULL
7131 };
7132
7133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7135 if (!SWIG_IsOK(res1)) {
7136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7137 }
7138 arg1 = reinterpret_cast< wxRect * >(argp1);
7139 ecode2 = SWIG_AsVal_int(obj1, &val2);
7140 if (!SWIG_IsOK(ecode2)) {
7141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7142 }
7143 arg2 = static_cast< int >(val2);
7144 ecode3 = SWIG_AsVal_int(obj2, &val3);
7145 if (!SWIG_IsOK(ecode3)) {
7146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7147 }
7148 arg3 = static_cast< int >(val3);
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 (arg1)->Offset(arg2,arg3);
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 resultobj = SWIG_Py_Void();
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj = 0;
7164 wxRect *arg1 = (wxRect *) 0 ;
7165 wxPoint *arg2 = 0 ;
7166 void *argp1 = 0 ;
7167 int res1 = 0 ;
7168 wxPoint temp2 ;
7169 PyObject * obj0 = 0 ;
7170 PyObject * obj1 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "self",(char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7177 if (!SWIG_IsOK(res1)) {
7178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7179 }
7180 arg1 = reinterpret_cast< wxRect * >(argp1);
7181 {
7182 arg2 = &temp2;
7183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 (arg1)->Offset((wxPoint const &)*arg2);
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 resultobj = SWIG_Py_Void();
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj = 0;
7200 wxRect *arg1 = (wxRect *) 0 ;
7201 wxRect *arg2 = 0 ;
7202 wxRect result;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 wxRect temp2 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "rect", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 {
7219 arg2 = &temp2;
7220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7221 }
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (arg1)->Intersect((wxRect const &)*arg2);
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxRect *arg1 = (wxRect *) 0 ;
7238 wxRect *arg2 = 0 ;
7239 wxRect result;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 wxRect temp2 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "rect", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7253 }
7254 arg1 = reinterpret_cast< wxRect * >(argp1);
7255 {
7256 arg2 = &temp2;
7257 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7258 }
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (arg1)->Union((wxRect const &)*arg2);
7262 wxPyEndAllowThreads(__tstate);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 wxRect *arg2 = 0 ;
7276 wxRect result;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 wxRect temp2 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 char * kwnames[] = {
7283 (char *) "self",(char *) "rect", NULL
7284 };
7285
7286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7288 if (!SWIG_IsOK(res1)) {
7289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7290 }
7291 arg1 = reinterpret_cast< wxRect * >(argp1);
7292 {
7293 arg2 = &temp2;
7294 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7295 }
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj = 0;
7311 wxRect *arg1 = (wxRect *) 0 ;
7312 wxRect *arg2 = 0 ;
7313 wxRect *result = 0 ;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 wxRect temp2 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 char * kwnames[] = {
7320 (char *) "self",(char *) "rect", NULL
7321 };
7322
7323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7325 if (!SWIG_IsOK(res1)) {
7326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7327 }
7328 arg1 = reinterpret_cast< wxRect * >(argp1);
7329 {
7330 arg2 = &temp2;
7331 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7332 }
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 {
7336 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7337 result = (wxRect *) &_result_ref;
7338 }
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj = 0;
7351 wxRect *arg1 = (wxRect *) 0 ;
7352 PyObject *arg2 = (PyObject *) 0 ;
7353 bool result;
7354 void *argp1 = 0 ;
7355 int res1 = 0 ;
7356 PyObject * obj0 = 0 ;
7357 PyObject * obj1 = 0 ;
7358 char * kwnames[] = {
7359 (char *) "self",(char *) "other", NULL
7360 };
7361
7362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7364 if (!SWIG_IsOK(res1)) {
7365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7366 }
7367 arg1 = reinterpret_cast< wxRect * >(argp1);
7368 arg2 = obj1;
7369 {
7370 result = (bool)wxRect___eq__(arg1,arg2);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 {
7374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7375 }
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7383 PyObject *resultobj = 0;
7384 wxRect *arg1 = (wxRect *) 0 ;
7385 PyObject *arg2 = (PyObject *) 0 ;
7386 bool result;
7387 void *argp1 = 0 ;
7388 int res1 = 0 ;
7389 PyObject * obj0 = 0 ;
7390 PyObject * obj1 = 0 ;
7391 char * kwnames[] = {
7392 (char *) "self",(char *) "other", NULL
7393 };
7394
7395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7399 }
7400 arg1 = reinterpret_cast< wxRect * >(argp1);
7401 arg2 = obj1;
7402 {
7403 result = (bool)wxRect___ne__(arg1,arg2);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 int arg2 ;
7419 int arg3 ;
7420 bool result;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 int val2 ;
7424 int ecode2 = 0 ;
7425 int val3 ;
7426 int ecode3 = 0 ;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 PyObject * obj2 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "x",(char *) "y", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 ecode2 = SWIG_AsVal_int(obj1, &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = static_cast< int >(val2);
7445 ecode3 = SWIG_AsVal_int(obj2, &val3);
7446 if (!SWIG_IsOK(ecode3)) {
7447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7448 }
7449 arg3 = static_cast< int >(val3);
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
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_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxPoint *arg2 = 0 ;
7469 bool result;
7470 void *argp1 = 0 ;
7471 int res1 = 0 ;
7472 wxPoint temp2 ;
7473 PyObject * obj0 = 0 ;
7474 PyObject * obj1 = 0 ;
7475 char * kwnames[] = {
7476 (char *) "self",(char *) "pt", NULL
7477 };
7478
7479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7481 if (!SWIG_IsOK(res1)) {
7482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7483 }
7484 arg1 = reinterpret_cast< wxRect * >(argp1);
7485 {
7486 arg2 = &temp2;
7487 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 {
7496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7497 }
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj = 0;
7506 wxRect *arg1 = (wxRect *) 0 ;
7507 wxRect *arg2 = 0 ;
7508 bool result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 wxRect temp2 ;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char * kwnames[] = {
7515 (char *) "self",(char *) "rect", NULL
7516 };
7517
7518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7520 if (!SWIG_IsOK(res1)) {
7521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7522 }
7523 arg1 = reinterpret_cast< wxRect * >(argp1);
7524 {
7525 arg2 = &temp2;
7526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7527 }
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxRect *arg2 = 0 ;
7547 int arg3 = (int) wxBOTH ;
7548 wxRect result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxRect temp2 ;
7552 int val3 ;
7553 int ecode3 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 PyObject * obj2 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "r",(char *) "dir", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7565 }
7566 arg1 = reinterpret_cast< wxRect * >(argp1);
7567 {
7568 arg2 = &temp2;
7569 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7570 }
7571 if (obj2) {
7572 ecode3 = SWIG_AsVal_int(obj2, &val3);
7573 if (!SWIG_IsOK(ecode3)) {
7574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7575 }
7576 arg3 = static_cast< int >(val3);
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7592 PyObject *resultobj = 0;
7593 wxRect *arg1 = (wxRect *) 0 ;
7594 int arg2 ;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 int val2 ;
7598 int ecode2 = 0 ;
7599 PyObject *swig_obj[2] ;
7600
7601 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7605 }
7606 arg1 = reinterpret_cast< wxRect * >(argp1);
7607 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7608 if (!SWIG_IsOK(ecode2)) {
7609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7610 }
7611 arg2 = static_cast< int >(val2);
7612 if (arg1) (arg1)->x = arg2;
7613
7614 resultobj = SWIG_Py_Void();
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 int result;
7625 void *argp1 = 0 ;
7626 int res1 = 0 ;
7627 PyObject *swig_obj[1] ;
7628
7629 if (!args) SWIG_fail;
7630 swig_obj[0] = args;
7631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7632 if (!SWIG_IsOK(res1)) {
7633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7634 }
7635 arg1 = reinterpret_cast< wxRect * >(argp1);
7636 result = (int) ((arg1)->x);
7637 resultobj = SWIG_From_int(static_cast< int >(result));
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxRect *arg1 = (wxRect *) 0 ;
7647 int arg2 ;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 int val2 ;
7651 int ecode2 = 0 ;
7652 PyObject *swig_obj[2] ;
7653
7654 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7656 if (!SWIG_IsOK(res1)) {
7657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7658 }
7659 arg1 = reinterpret_cast< wxRect * >(argp1);
7660 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7661 if (!SWIG_IsOK(ecode2)) {
7662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7663 }
7664 arg2 = static_cast< int >(val2);
7665 if (arg1) (arg1)->y = arg2;
7666
7667 resultobj = SWIG_Py_Void();
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7675 PyObject *resultobj = 0;
7676 wxRect *arg1 = (wxRect *) 0 ;
7677 int result;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 PyObject *swig_obj[1] ;
7681
7682 if (!args) SWIG_fail;
7683 swig_obj[0] = args;
7684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7685 if (!SWIG_IsOK(res1)) {
7686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7687 }
7688 arg1 = reinterpret_cast< wxRect * >(argp1);
7689 result = (int) ((arg1)->y);
7690 resultobj = SWIG_From_int(static_cast< int >(result));
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7698 PyObject *resultobj = 0;
7699 wxRect *arg1 = (wxRect *) 0 ;
7700 int arg2 ;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 int val2 ;
7704 int ecode2 = 0 ;
7705 PyObject *swig_obj[2] ;
7706
7707 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7709 if (!SWIG_IsOK(res1)) {
7710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7711 }
7712 arg1 = reinterpret_cast< wxRect * >(argp1);
7713 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7714 if (!SWIG_IsOK(ecode2)) {
7715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7716 }
7717 arg2 = static_cast< int >(val2);
7718 if (arg1) (arg1)->width = arg2;
7719
7720 resultobj = SWIG_Py_Void();
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7728 PyObject *resultobj = 0;
7729 wxRect *arg1 = (wxRect *) 0 ;
7730 int result;
7731 void *argp1 = 0 ;
7732 int res1 = 0 ;
7733 PyObject *swig_obj[1] ;
7734
7735 if (!args) SWIG_fail;
7736 swig_obj[0] = args;
7737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7738 if (!SWIG_IsOK(res1)) {
7739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7740 }
7741 arg1 = reinterpret_cast< wxRect * >(argp1);
7742 result = (int) ((arg1)->width);
7743 resultobj = SWIG_From_int(static_cast< int >(result));
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7751 PyObject *resultobj = 0;
7752 wxRect *arg1 = (wxRect *) 0 ;
7753 int arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 int val2 ;
7757 int ecode2 = 0 ;
7758 PyObject *swig_obj[2] ;
7759
7760 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7764 }
7765 arg1 = reinterpret_cast< wxRect * >(argp1);
7766 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7767 if (!SWIG_IsOK(ecode2)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7769 }
7770 arg2 = static_cast< int >(val2);
7771 if (arg1) (arg1)->height = arg2;
7772
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7781 PyObject *resultobj = 0;
7782 wxRect *arg1 = (wxRect *) 0 ;
7783 int result;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 PyObject *swig_obj[1] ;
7787
7788 if (!args) SWIG_fail;
7789 swig_obj[0] = args;
7790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7793 }
7794 arg1 = reinterpret_cast< wxRect * >(argp1);
7795 result = (int) ((arg1)->height);
7796 resultobj = SWIG_From_int(static_cast< int >(result));
7797 return resultobj;
7798 fail:
7799 return NULL;
7800 }
7801
7802
7803 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj = 0;
7805 wxRect *arg1 = (wxRect *) 0 ;
7806 int arg2 = (int) 0 ;
7807 int arg3 = (int) 0 ;
7808 int arg4 = (int) 0 ;
7809 int arg5 = (int) 0 ;
7810 void *argp1 = 0 ;
7811 int res1 = 0 ;
7812 int val2 ;
7813 int ecode2 = 0 ;
7814 int val3 ;
7815 int ecode3 = 0 ;
7816 int val4 ;
7817 int ecode4 = 0 ;
7818 int val5 ;
7819 int ecode5 = 0 ;
7820 PyObject * obj0 = 0 ;
7821 PyObject * obj1 = 0 ;
7822 PyObject * obj2 = 0 ;
7823 PyObject * obj3 = 0 ;
7824 PyObject * obj4 = 0 ;
7825 char * kwnames[] = {
7826 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7827 };
7828
7829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7831 if (!SWIG_IsOK(res1)) {
7832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7833 }
7834 arg1 = reinterpret_cast< wxRect * >(argp1);
7835 if (obj1) {
7836 ecode2 = SWIG_AsVal_int(obj1, &val2);
7837 if (!SWIG_IsOK(ecode2)) {
7838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7839 }
7840 arg2 = static_cast< int >(val2);
7841 }
7842 if (obj2) {
7843 ecode3 = SWIG_AsVal_int(obj2, &val3);
7844 if (!SWIG_IsOK(ecode3)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7846 }
7847 arg3 = static_cast< int >(val3);
7848 }
7849 if (obj3) {
7850 ecode4 = SWIG_AsVal_int(obj3, &val4);
7851 if (!SWIG_IsOK(ecode4)) {
7852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7853 }
7854 arg4 = static_cast< int >(val4);
7855 }
7856 if (obj4) {
7857 ecode5 = SWIG_AsVal_int(obj4, &val5);
7858 if (!SWIG_IsOK(ecode5)) {
7859 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7860 }
7861 arg5 = static_cast< int >(val5);
7862 }
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 resultobj = SWIG_Py_Void();
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7877 PyObject *resultobj = 0;
7878 wxRect *arg1 = (wxRect *) 0 ;
7879 PyObject *result = 0 ;
7880 void *argp1 = 0 ;
7881 int res1 = 0 ;
7882 PyObject *swig_obj[1] ;
7883
7884 if (!args) SWIG_fail;
7885 swig_obj[0] = args;
7886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7889 }
7890 arg1 = reinterpret_cast< wxRect * >(argp1);
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (PyObject *)wxRect_Get(arg1);
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = result;
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 PyObject *obj;
7906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7907 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7908 return SWIG_Py_Void();
7909 }
7910
7911 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 return SWIG_Python_InitShadowInstance(args);
7913 }
7914
7915 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7916 PyObject *resultobj = 0;
7917 wxRect *arg1 = (wxRect *) 0 ;
7918 wxRect *arg2 = (wxRect *) 0 ;
7919 PyObject *result = 0 ;
7920 void *argp1 = 0 ;
7921 int res1 = 0 ;
7922 void *argp2 = 0 ;
7923 int res2 = 0 ;
7924 PyObject * obj0 = 0 ;
7925 PyObject * obj1 = 0 ;
7926 char * kwnames[] = {
7927 (char *) "r1",(char *) "r2", NULL
7928 };
7929
7930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7932 if (!SWIG_IsOK(res1)) {
7933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7934 }
7935 arg1 = reinterpret_cast< wxRect * >(argp1);
7936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7937 if (!SWIG_IsOK(res2)) {
7938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7939 }
7940 arg2 = reinterpret_cast< wxRect * >(argp2);
7941 {
7942 if (!wxPyCheckForApp()) SWIG_fail;
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (PyObject *)wxIntersectRect(arg1,arg2);
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 resultobj = result;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj = 0;
7957 double arg1 = (double) 0.0 ;
7958 double arg2 = (double) 0.0 ;
7959 wxPoint2D *result = 0 ;
7960 double val1 ;
7961 int ecode1 = 0 ;
7962 double val2 ;
7963 int ecode2 = 0 ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 char * kwnames[] = {
7967 (char *) "x",(char *) "y", NULL
7968 };
7969
7970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7971 if (obj0) {
7972 ecode1 = SWIG_AsVal_double(obj0, &val1);
7973 if (!SWIG_IsOK(ecode1)) {
7974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7975 }
7976 arg1 = static_cast< double >(val1);
7977 }
7978 if (obj1) {
7979 ecode2 = SWIG_AsVal_double(obj1, &val2);
7980 if (!SWIG_IsOK(ecode2)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7982 }
7983 arg2 = static_cast< double >(val2);
7984 }
7985 {
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7999 PyObject *resultobj = 0;
8000 wxPoint2D *arg1 = 0 ;
8001 wxPoint2D *result = 0 ;
8002 wxPoint2D temp1 ;
8003 PyObject * obj0 = 0 ;
8004 char * kwnames[] = {
8005 (char *) "pt", NULL
8006 };
8007
8008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8009 {
8010 arg1 = &temp1;
8011 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8012 }
8013 {
8014 PyThreadState* __tstate = wxPyBeginAllowThreads();
8015 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj = 0;
8028 wxPoint *arg1 = 0 ;
8029 wxPoint2D *result = 0 ;
8030 wxPoint temp1 ;
8031 PyObject * obj0 = 0 ;
8032 char * kwnames[] = {
8033 (char *) "pt", NULL
8034 };
8035
8036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8037 {
8038 arg1 = &temp1;
8039 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8040 }
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8044 wxPyEndAllowThreads(__tstate);
8045 if (PyErr_Occurred()) SWIG_fail;
8046 }
8047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8048 return resultobj;
8049 fail:
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8057 int *arg2 = (int *) 0 ;
8058 int *arg3 = (int *) 0 ;
8059 void *argp1 = 0 ;
8060 int res1 = 0 ;
8061 int temp2 ;
8062 int res2 = SWIG_TMPOBJ ;
8063 int temp3 ;
8064 int res3 = SWIG_TMPOBJ ;
8065 PyObject *swig_obj[1] ;
8066
8067 arg2 = &temp2;
8068 arg3 = &temp3;
8069 if (!args) SWIG_fail;
8070 swig_obj[0] = args;
8071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8072 if (!SWIG_IsOK(res1)) {
8073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8074 }
8075 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 if (SWIG_IsTmpObj(res2)) {
8084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8085 } else {
8086 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8088 }
8089 if (SWIG_IsTmpObj(res3)) {
8090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8091 } else {
8092 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8094 }
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8102 PyObject *resultobj = 0;
8103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8104 int *arg2 = (int *) 0 ;
8105 int *arg3 = (int *) 0 ;
8106 void *argp1 = 0 ;
8107 int res1 = 0 ;
8108 int temp2 ;
8109 int res2 = SWIG_TMPOBJ ;
8110 int temp3 ;
8111 int res3 = SWIG_TMPOBJ ;
8112 PyObject *swig_obj[1] ;
8113
8114 arg2 = &temp2;
8115 arg3 = &temp3;
8116 if (!args) SWIG_fail;
8117 swig_obj[0] = args;
8118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8119 if (!SWIG_IsOK(res1)) {
8120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8121 }
8122 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8123 {
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8126 wxPyEndAllowThreads(__tstate);
8127 if (PyErr_Occurred()) SWIG_fail;
8128 }
8129 resultobj = SWIG_Py_Void();
8130 if (SWIG_IsTmpObj(res2)) {
8131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8132 } else {
8133 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8135 }
8136 if (SWIG_IsTmpObj(res3)) {
8137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8138 } else {
8139 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8141 }
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8149 PyObject *resultobj = 0;
8150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8151 double result;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 PyObject *swig_obj[1] ;
8155
8156 if (!args) SWIG_fail;
8157 swig_obj[0] = args;
8158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8159 if (!SWIG_IsOK(res1)) {
8160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8161 }
8162 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 resultobj = SWIG_From_double(static_cast< double >(result));
8170 return resultobj;
8171 fail:
8172 return NULL;
8173 }
8174
8175
8176 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 PyObject *resultobj = 0;
8178 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8179 double result;
8180 void *argp1 = 0 ;
8181 int res1 = 0 ;
8182 PyObject *swig_obj[1] ;
8183
8184 if (!args) SWIG_fail;
8185 swig_obj[0] = args;
8186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8187 if (!SWIG_IsOK(res1)) {
8188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8189 }
8190 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8194 wxPyEndAllowThreads(__tstate);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 resultobj = SWIG_From_double(static_cast< double >(result));
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj = 0;
8206 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8207 double arg2 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 double val2 ;
8211 int ecode2 = 0 ;
8212 PyObject * obj0 = 0 ;
8213 PyObject * obj1 = 0 ;
8214 char * kwnames[] = {
8215 (char *) "self",(char *) "length", NULL
8216 };
8217
8218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8220 if (!SWIG_IsOK(res1)) {
8221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8222 }
8223 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8224 ecode2 = SWIG_AsVal_double(obj1, &val2);
8225 if (!SWIG_IsOK(ecode2)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8227 }
8228 arg2 = static_cast< double >(val2);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 (arg1)->SetVectorLength(arg2);
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 resultobj = SWIG_Py_Void();
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj = 0;
8244 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8245 double arg2 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 double val2 ;
8249 int ecode2 = 0 ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "degrees", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8260 }
8261 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8262 ecode2 = SWIG_AsVal_double(obj1, &val2);
8263 if (!SWIG_IsOK(ecode2)) {
8264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8265 }
8266 arg2 = static_cast< double >(val2);
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetVectorAngle(arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj = 0;
8282 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8283 wxPoint2D *arg2 = 0 ;
8284 double result;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 wxPoint2D temp2 ;
8288 PyObject * obj0 = 0 ;
8289 PyObject * obj1 = 0 ;
8290 char * kwnames[] = {
8291 (char *) "self",(char *) "pt", NULL
8292 };
8293
8294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8296 if (!SWIG_IsOK(res1)) {
8297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8298 }
8299 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8300 {
8301 arg2 = &temp2;
8302 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8303 }
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 resultobj = SWIG_From_double(static_cast< double >(result));
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj = 0;
8319 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8320 wxPoint2D *arg2 = 0 ;
8321 double result;
8322 void *argp1 = 0 ;
8323 int res1 = 0 ;
8324 wxPoint2D temp2 ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 char * kwnames[] = {
8328 (char *) "self",(char *) "pt", NULL
8329 };
8330
8331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8335 }
8336 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8337 {
8338 arg2 = &temp2;
8339 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 resultobj = SWIG_From_double(static_cast< double >(result));
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj = 0;
8356 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8357 wxPoint2D *arg2 = 0 ;
8358 double result;
8359 void *argp1 = 0 ;
8360 int res1 = 0 ;
8361 wxPoint2D temp2 ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 char * kwnames[] = {
8365 (char *) "self",(char *) "vec", NULL
8366 };
8367
8368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8370 if (!SWIG_IsOK(res1)) {
8371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8372 }
8373 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8374 {
8375 arg2 = &temp2;
8376 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 resultobj = SWIG_From_double(static_cast< double >(result));
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj = 0;
8393 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8394 wxPoint2D *arg2 = 0 ;
8395 double result;
8396 void *argp1 = 0 ;
8397 int res1 = 0 ;
8398 wxPoint2D temp2 ;
8399 PyObject * obj0 = 0 ;
8400 PyObject * obj1 = 0 ;
8401 char * kwnames[] = {
8402 (char *) "self",(char *) "vec", NULL
8403 };
8404
8405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8407 if (!SWIG_IsOK(res1)) {
8408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8409 }
8410 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8411 {
8412 arg2 = &temp2;
8413 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8414 }
8415 {
8416 PyThreadState* __tstate = wxPyBeginAllowThreads();
8417 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 resultobj = SWIG_From_double(static_cast< double >(result));
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8429 PyObject *resultobj = 0;
8430 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8431 wxPoint2D result;
8432 void *argp1 = 0 ;
8433 int res1 = 0 ;
8434 PyObject *swig_obj[1] ;
8435
8436 if (!args) SWIG_fail;
8437 swig_obj[0] = args;
8438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8439 if (!SWIG_IsOK(res1)) {
8440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8441 }
8442 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->operator -();
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 wxPoint2D *result = 0 ;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "pt", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 {
8483 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8484 result = (wxPoint2D *) &_result_ref;
8485 }
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj = 0;
8498 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8499 wxPoint2D *arg2 = 0 ;
8500 wxPoint2D *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 wxPoint2D temp2 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "pt", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8514 }
8515 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8516 {
8517 arg2 = &temp2;
8518 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 {
8523 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8524 result = (wxPoint2D *) &_result_ref;
8525 }
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 wxPoint2D *result = 0 ;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 {
8563 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8564 result = (wxPoint2D *) &_result_ref;
8565 }
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj = 0;
8578 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8579 wxPoint2D *arg2 = 0 ;
8580 wxPoint2D *result = 0 ;
8581 void *argp1 = 0 ;
8582 int res1 = 0 ;
8583 wxPoint2D temp2 ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 char * kwnames[] = {
8587 (char *) "self",(char *) "pt", NULL
8588 };
8589
8590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8592 if (!SWIG_IsOK(res1)) {
8593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8594 }
8595 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8596 {
8597 arg2 = &temp2;
8598 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 {
8603 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8604 result = (wxPoint2D *) &_result_ref;
8605 }
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8617 PyObject *resultobj = 0;
8618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8619 PyObject *arg2 = (PyObject *) 0 ;
8620 bool result;
8621 void *argp1 = 0 ;
8622 int res1 = 0 ;
8623 PyObject * obj0 = 0 ;
8624 PyObject * obj1 = 0 ;
8625 char * kwnames[] = {
8626 (char *) "self",(char *) "other", NULL
8627 };
8628
8629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8631 if (!SWIG_IsOK(res1)) {
8632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8633 }
8634 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8635 arg2 = obj1;
8636 {
8637 result = (bool)wxPoint2D___eq__(arg1,arg2);
8638 if (PyErr_Occurred()) SWIG_fail;
8639 }
8640 {
8641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8652 PyObject *arg2 = (PyObject *) 0 ;
8653 bool result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 PyObject * obj0 = 0 ;
8657 PyObject * obj1 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "other", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8666 }
8667 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8668 arg2 = obj1;
8669 {
8670 result = (bool)wxPoint2D___ne__(arg1,arg2);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 {
8674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8675 }
8676 return resultobj;
8677 fail:
8678 return NULL;
8679 }
8680
8681
8682 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8683 PyObject *resultobj = 0;
8684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8685 double arg2 ;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 double val2 ;
8689 int ecode2 = 0 ;
8690 PyObject *swig_obj[2] ;
8691
8692 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8699 if (!SWIG_IsOK(ecode2)) {
8700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8701 }
8702 arg2 = static_cast< double >(val2);
8703 if (arg1) (arg1)->m_x = arg2;
8704
8705 resultobj = SWIG_Py_Void();
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8713 PyObject *resultobj = 0;
8714 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8715 double result;
8716 void *argp1 = 0 ;
8717 int res1 = 0 ;
8718 PyObject *swig_obj[1] ;
8719
8720 if (!args) SWIG_fail;
8721 swig_obj[0] = args;
8722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8725 }
8726 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8727 result = (double) ((arg1)->m_x);
8728 resultobj = SWIG_From_double(static_cast< double >(result));
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8736 PyObject *resultobj = 0;
8737 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8738 double arg2 ;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 double val2 ;
8742 int ecode2 = 0 ;
8743 PyObject *swig_obj[2] ;
8744
8745 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8747 if (!SWIG_IsOK(res1)) {
8748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8749 }
8750 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8751 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8752 if (!SWIG_IsOK(ecode2)) {
8753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8754 }
8755 arg2 = static_cast< double >(val2);
8756 if (arg1) (arg1)->m_y = arg2;
8757
8758 resultobj = SWIG_Py_Void();
8759 return resultobj;
8760 fail:
8761 return NULL;
8762 }
8763
8764
8765 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8766 PyObject *resultobj = 0;
8767 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8768 double result;
8769 void *argp1 = 0 ;
8770 int res1 = 0 ;
8771 PyObject *swig_obj[1] ;
8772
8773 if (!args) SWIG_fail;
8774 swig_obj[0] = args;
8775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 result = (double) ((arg1)->m_y);
8781 resultobj = SWIG_From_double(static_cast< double >(result));
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8791 double arg2 = (double) 0 ;
8792 double arg3 = (double) 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 double val2 ;
8796 int ecode2 = 0 ;
8797 double val3 ;
8798 int ecode3 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "x",(char *) "y", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 if (obj1) {
8813 ecode2 = SWIG_AsVal_double(obj1, &val2);
8814 if (!SWIG_IsOK(ecode2)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8816 }
8817 arg2 = static_cast< double >(val2);
8818 }
8819 if (obj2) {
8820 ecode3 = SWIG_AsVal_double(obj2, &val3);
8821 if (!SWIG_IsOK(ecode3)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8823 }
8824 arg3 = static_cast< double >(val3);
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 wxPoint2D_Set(arg1,arg2,arg3);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 resultobj = SWIG_Py_Void();
8833 return resultobj;
8834 fail:
8835 return NULL;
8836 }
8837
8838
8839 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8840 PyObject *resultobj = 0;
8841 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8842 PyObject *result = 0 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 PyObject *swig_obj[1] ;
8846
8847 if (!args) SWIG_fail;
8848 swig_obj[0] = args;
8849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8852 }
8853 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (PyObject *)wxPoint2D_Get(arg1);
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 resultobj = result;
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *obj;
8869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8870 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8871 return SWIG_Py_Void();
8872 }
8873
8874 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8875 return SWIG_Python_InitShadowInstance(args);
8876 }
8877
8878 SWIGINTERN int DefaultPosition_set(PyObject *) {
8879 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8880 return 1;
8881 }
8882
8883
8884 SWIGINTERN PyObject *DefaultPosition_get(void) {
8885 PyObject *pyobj = 0;
8886
8887 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8888 return pyobj;
8889 }
8890
8891
8892 SWIGINTERN int DefaultSize_set(PyObject *) {
8893 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8894 return 1;
8895 }
8896
8897
8898 SWIGINTERN PyObject *DefaultSize_get(void) {
8899 PyObject *pyobj = 0;
8900
8901 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8902 return pyobj;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 PyObject *arg1 = (PyObject *) 0 ;
8909 wxPyInputStream *result = 0 ;
8910 PyObject * obj0 = 0 ;
8911 char * kwnames[] = {
8912 (char *) "p", NULL
8913 };
8914
8915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8916 arg1 = obj0;
8917 {
8918 PyThreadState* __tstate = wxPyBeginAllowThreads();
8919 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8931 PyObject *resultobj = 0;
8932 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 PyObject *swig_obj[1] ;
8936
8937 if (!args) SWIG_fail;
8938 swig_obj[0] = args;
8939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8942 }
8943 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 delete arg1;
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 resultobj = SWIG_Py_Void();
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 PyObject *resultobj = 0;
8960 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 (arg1)->close();
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_Py_Void();
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *resultobj = 0;
8987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8988 void *argp1 = 0 ;
8989 int res1 = 0 ;
8990 PyObject *swig_obj[1] ;
8991
8992 if (!args) SWIG_fail;
8993 swig_obj[0] = args;
8994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8995 if (!SWIG_IsOK(res1)) {
8996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8997 }
8998 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 (arg1)->flush();
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 resultobj = SWIG_Py_Void();
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9013 PyObject *resultobj = 0;
9014 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9015 bool result;
9016 void *argp1 = 0 ;
9017 int res1 = 0 ;
9018 PyObject *swig_obj[1] ;
9019
9020 if (!args) SWIG_fail;
9021 swig_obj[0] = args;
9022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9023 if (!SWIG_IsOK(res1)) {
9024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9025 }
9026 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 result = (bool)(arg1)->eof();
9030 wxPyEndAllowThreads(__tstate);
9031 if (PyErr_Occurred()) SWIG_fail;
9032 }
9033 {
9034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9035 }
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj = 0;
9044 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9045 int arg2 = (int) -1 ;
9046 PyObject *result = 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 int val2 ;
9050 int ecode2 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 PyObject * obj1 = 0 ;
9053 char * kwnames[] = {
9054 (char *) "self",(char *) "size", NULL
9055 };
9056
9057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9061 }
9062 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9063 if (obj1) {
9064 ecode2 = SWIG_AsVal_int(obj1, &val2);
9065 if (!SWIG_IsOK(ecode2)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9067 }
9068 arg2 = static_cast< int >(val2);
9069 }
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 result = (PyObject *)(arg1)->read(arg2);
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 resultobj = result;
9077 return resultobj;
9078 fail:
9079 return NULL;
9080 }
9081
9082
9083 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9084 PyObject *resultobj = 0;
9085 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9086 int arg2 = (int) -1 ;
9087 PyObject *result = 0 ;
9088 void *argp1 = 0 ;
9089 int res1 = 0 ;
9090 int val2 ;
9091 int ecode2 = 0 ;
9092 PyObject * obj0 = 0 ;
9093 PyObject * obj1 = 0 ;
9094 char * kwnames[] = {
9095 (char *) "self",(char *) "size", NULL
9096 };
9097
9098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9100 if (!SWIG_IsOK(res1)) {
9101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9102 }
9103 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9104 if (obj1) {
9105 ecode2 = SWIG_AsVal_int(obj1, &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9108 }
9109 arg2 = static_cast< int >(val2);
9110 }
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 result = (PyObject *)(arg1)->readline(arg2);
9114 wxPyEndAllowThreads(__tstate);
9115 if (PyErr_Occurred()) SWIG_fail;
9116 }
9117 resultobj = result;
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9125 PyObject *resultobj = 0;
9126 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9127 int arg2 = (int) -1 ;
9128 PyObject *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 int val2 ;
9132 int ecode2 = 0 ;
9133 PyObject * obj0 = 0 ;
9134 PyObject * obj1 = 0 ;
9135 char * kwnames[] = {
9136 (char *) "self",(char *) "sizehint", NULL
9137 };
9138
9139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 if (obj1) {
9146 ecode2 = SWIG_AsVal_int(obj1, &val2);
9147 if (!SWIG_IsOK(ecode2)) {
9148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9149 }
9150 arg2 = static_cast< int >(val2);
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = (PyObject *)(arg1)->readlines(arg2);
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = result;
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9166 PyObject *resultobj = 0;
9167 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9168 int arg2 ;
9169 int arg3 = (int) 0 ;
9170 void *argp1 = 0 ;
9171 int res1 = 0 ;
9172 int val2 ;
9173 int ecode2 = 0 ;
9174 int val3 ;
9175 int ecode3 = 0 ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 PyObject * obj2 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "self",(char *) "offset",(char *) "whence", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 ecode2 = SWIG_AsVal_int(obj1, &val2);
9190 if (!SWIG_IsOK(ecode2)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9192 }
9193 arg2 = static_cast< int >(val2);
9194 if (obj2) {
9195 ecode3 = SWIG_AsVal_int(obj2, &val3);
9196 if (!SWIG_IsOK(ecode3)) {
9197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9198 }
9199 arg3 = static_cast< int >(val3);
9200 }
9201 {
9202 PyThreadState* __tstate = wxPyBeginAllowThreads();
9203 (arg1)->seek(arg2,arg3);
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 resultobj = SWIG_Py_Void();
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 PyObject *resultobj = 0;
9216 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9217 int result;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 PyObject *swig_obj[1] ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9227 }
9228 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (int)(arg1)->tell();
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_From_int(static_cast< int >(result));
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 char result;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 PyObject *swig_obj[1] ;
9249
9250 if (!args) SWIG_fail;
9251 swig_obj[0] = args;
9252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9253 if (!SWIG_IsOK(res1)) {
9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9255 }
9256 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (char)(arg1)->Peek();
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 resultobj = SWIG_From_char(static_cast< char >(result));
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9271 PyObject *resultobj = 0;
9272 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9273 char result;
9274 void *argp1 = 0 ;
9275 int res1 = 0 ;
9276 PyObject *swig_obj[1] ;
9277
9278 if (!args) SWIG_fail;
9279 swig_obj[0] = args;
9280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9281 if (!SWIG_IsOK(res1)) {
9282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9283 }
9284 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 result = (char)(arg1)->GetC();
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_From_char(static_cast< char >(result));
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9299 PyObject *resultobj = 0;
9300 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9301 size_t result;
9302 void *argp1 = 0 ;
9303 int res1 = 0 ;
9304 PyObject *swig_obj[1] ;
9305
9306 if (!args) SWIG_fail;
9307 swig_obj[0] = args;
9308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9309 if (!SWIG_IsOK(res1)) {
9310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9311 }
9312 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 result = (size_t)(arg1)->LastRead();
9316 wxPyEndAllowThreads(__tstate);
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9320 return resultobj;
9321 fail:
9322 return NULL;
9323 }
9324
9325
9326 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9327 PyObject *resultobj = 0;
9328 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9329 bool result;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 PyObject *swig_obj[1] ;
9333
9334 if (!args) SWIG_fail;
9335 swig_obj[0] = args;
9336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (bool)(arg1)->CanRead();
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 {
9348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9349 }
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9357 PyObject *resultobj = 0;
9358 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9359 bool result;
9360 void *argp1 = 0 ;
9361 int res1 = 0 ;
9362 PyObject *swig_obj[1] ;
9363
9364 if (!args) SWIG_fail;
9365 swig_obj[0] = args;
9366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9367 if (!SWIG_IsOK(res1)) {
9368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9369 }
9370 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (bool)(arg1)->Eof();
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9379 }
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9387 PyObject *resultobj = 0;
9388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9389 char arg2 ;
9390 bool result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 char val2 ;
9394 int ecode2 = 0 ;
9395 PyObject * obj0 = 0 ;
9396 PyObject * obj1 = 0 ;
9397 char * kwnames[] = {
9398 (char *) "self",(char *) "c", NULL
9399 };
9400
9401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9403 if (!SWIG_IsOK(res1)) {
9404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9405 }
9406 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9407 ecode2 = SWIG_AsVal_char(obj1, &val2);
9408 if (!SWIG_IsOK(ecode2)) {
9409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9410 }
9411 arg2 = static_cast< char >(val2);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (bool)(arg1)->Ungetch(arg2);
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 {
9419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9420 }
9421 return resultobj;
9422 fail:
9423 return NULL;
9424 }
9425
9426
9427 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9428 PyObject *resultobj = 0;
9429 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9430 long arg2 ;
9431 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9432 long result;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 long val2 ;
9436 int ecode2 = 0 ;
9437 int val3 ;
9438 int ecode3 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 PyObject * obj2 = 0 ;
9442 char * kwnames[] = {
9443 (char *) "self",(char *) "pos",(char *) "mode", NULL
9444 };
9445
9446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9448 if (!SWIG_IsOK(res1)) {
9449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9450 }
9451 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9452 ecode2 = SWIG_AsVal_long(obj1, &val2);
9453 if (!SWIG_IsOK(ecode2)) {
9454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9455 }
9456 arg2 = static_cast< long >(val2);
9457 if (obj2) {
9458 ecode3 = SWIG_AsVal_int(obj2, &val3);
9459 if (!SWIG_IsOK(ecode3)) {
9460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9461 }
9462 arg3 = static_cast< wxSeekMode >(val3);
9463 }
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (long)(arg1)->SeekI(arg2,arg3);
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_From_long(static_cast< long >(result));
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9478 PyObject *resultobj = 0;
9479 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9480 long result;
9481 void *argp1 = 0 ;
9482 int res1 = 0 ;
9483 PyObject *swig_obj[1] ;
9484
9485 if (!args) SWIG_fail;
9486 swig_obj[0] = args;
9487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9488 if (!SWIG_IsOK(res1)) {
9489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9490 }
9491 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (long)(arg1)->TellI();
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 resultobj = SWIG_From_long(static_cast< long >(result));
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9506 PyObject *obj;
9507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9508 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9509 return SWIG_Py_Void();
9510 }
9511
9512 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9513 return SWIG_Python_InitShadowInstance(args);
9514 }
9515
9516 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9519 PyObject *arg2 = (PyObject *) 0 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 PyObject * obj0 = 0 ;
9523 PyObject * obj1 = 0 ;
9524 char * kwnames[] = {
9525 (char *) "self",(char *) "obj", NULL
9526 };
9527
9528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9530 if (!SWIG_IsOK(res1)) {
9531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9532 }
9533 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9534 arg2 = obj1;
9535 {
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 wxOutputStream_write(arg1,arg2);
9538 wxPyEndAllowThreads(__tstate);
9539 if (PyErr_Occurred()) SWIG_fail;
9540 }
9541 resultobj = SWIG_Py_Void();
9542 return resultobj;
9543 fail:
9544 return NULL;
9545 }
9546
9547
9548 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9549 PyObject *resultobj = 0;
9550 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9551 size_t result;
9552 void *argp1 = 0 ;
9553 int res1 = 0 ;
9554 PyObject *swig_obj[1] ;
9555
9556 if (!args) SWIG_fail;
9557 swig_obj[0] = args;
9558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9561 }
9562 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9570 return resultobj;
9571 fail:
9572 return NULL;
9573 }
9574
9575
9576 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9577 PyObject *obj;
9578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9579 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9580 return SWIG_Py_Void();
9581 }
9582
9583 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 wxInputStream *arg1 = (wxInputStream *) 0 ;
9586 wxString *arg2 = 0 ;
9587 wxString *arg3 = 0 ;
9588 wxString *arg4 = 0 ;
9589 wxDateTime arg5 ;
9590 wxFSFile *result = 0 ;
9591 wxPyInputStream *temp1 ;
9592 bool temp2 = false ;
9593 bool temp3 = false ;
9594 bool temp4 = false ;
9595 void *argp5 ;
9596 int res5 = 0 ;
9597 PyObject * obj0 = 0 ;
9598 PyObject * obj1 = 0 ;
9599 PyObject * obj2 = 0 ;
9600 PyObject * obj3 = 0 ;
9601 PyObject * obj4 = 0 ;
9602 char * kwnames[] = {
9603 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9604 };
9605
9606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9607 {
9608 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9609 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9610 } else {
9611 PyErr_Clear(); // clear the failure of the wxPyConvert above
9612 arg1 = wxPyCBInputStream_create(obj0, true);
9613 if (arg1 == NULL) {
9614 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9615 SWIG_fail;
9616 }
9617 }
9618 }
9619 {
9620 arg2 = wxString_in_helper(obj1);
9621 if (arg2 == NULL) SWIG_fail;
9622 temp2 = true;
9623 }
9624 {
9625 arg3 = wxString_in_helper(obj2);
9626 if (arg3 == NULL) SWIG_fail;
9627 temp3 = true;
9628 }
9629 {
9630 arg4 = wxString_in_helper(obj3);
9631 if (arg4 == NULL) SWIG_fail;
9632 temp4 = true;
9633 }
9634 {
9635 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9636 if (!SWIG_IsOK(res5)) {
9637 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9638 }
9639 if (!argp5) {
9640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9641 } else {
9642 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9643 arg5 = *temp;
9644 if (SWIG_IsNewObj(res5)) delete temp;
9645 }
9646 }
9647 {
9648 PyThreadState* __tstate = wxPyBeginAllowThreads();
9649 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9650 wxPyEndAllowThreads(__tstate);
9651 if (PyErr_Occurred()) SWIG_fail;
9652 }
9653 {
9654 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9655 }
9656 {
9657 if (temp2)
9658 delete arg2;
9659 }
9660 {
9661 if (temp3)
9662 delete arg3;
9663 }
9664 {
9665 if (temp4)
9666 delete arg4;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp2)
9672 delete arg2;
9673 }
9674 {
9675 if (temp3)
9676 delete arg3;
9677 }
9678 {
9679 if (temp4)
9680 delete arg4;
9681 }
9682 return NULL;
9683 }
9684
9685
9686 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9687 PyObject *resultobj = 0;
9688 wxFSFile *arg1 = (wxFSFile *) 0 ;
9689 void *argp1 = 0 ;
9690 int res1 = 0 ;
9691 PyObject *swig_obj[1] ;
9692
9693 if (!args) SWIG_fail;
9694 swig_obj[0] = args;
9695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9696 if (!SWIG_IsOK(res1)) {
9697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9698 }
9699 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9700 {
9701 PyThreadState* __tstate = wxPyBeginAllowThreads();
9702 delete arg1;
9703
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_Py_Void();
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9715 PyObject *resultobj = 0;
9716 wxFSFile *arg1 = (wxFSFile *) 0 ;
9717 wxInputStream *result = 0 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 PyObject *swig_obj[1] ;
9721
9722 if (!args) SWIG_fail;
9723 swig_obj[0] = args;
9724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9725 if (!SWIG_IsOK(res1)) {
9726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9727 }
9728 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 result = (wxInputStream *)(arg1)->GetStream();
9732 wxPyEndAllowThreads(__tstate);
9733 if (PyErr_Occurred()) SWIG_fail;
9734 }
9735 {
9736 wxPyInputStream * _ptr = NULL;
9737
9738 if (result) {
9739 _ptr = new wxPyInputStream(result);
9740 }
9741 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9742 }
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9750 PyObject *resultobj = 0;
9751 wxFSFile *arg1 = (wxFSFile *) 0 ;
9752 wxString *result = 0 ;
9753 void *argp1 = 0 ;
9754 int res1 = 0 ;
9755 PyObject *swig_obj[1] ;
9756
9757 if (!args) SWIG_fail;
9758 swig_obj[0] = args;
9759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9762 }
9763 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 {
9767 wxString const &_result_ref = (arg1)->GetMimeType();
9768 result = (wxString *) &_result_ref;
9769 }
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 {
9774 #if wxUSE_UNICODE
9775 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9776 #else
9777 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9778 #endif
9779 }
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFSFile *arg1 = (wxFSFile *) 0 ;
9789 wxString *result = 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 PyObject *swig_obj[1] ;
9793
9794 if (!args) SWIG_fail;
9795 swig_obj[0] = args;
9796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9799 }
9800 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 {
9804 wxString const &_result_ref = (arg1)->GetLocation();
9805 result = (wxString *) &_result_ref;
9806 }
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 {
9811 #if wxUSE_UNICODE
9812 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9813 #else
9814 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9815 #endif
9816 }
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9824 PyObject *resultobj = 0;
9825 wxFSFile *arg1 = (wxFSFile *) 0 ;
9826 wxString *result = 0 ;
9827 void *argp1 = 0 ;
9828 int res1 = 0 ;
9829 PyObject *swig_obj[1] ;
9830
9831 if (!args) SWIG_fail;
9832 swig_obj[0] = args;
9833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9834 if (!SWIG_IsOK(res1)) {
9835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9836 }
9837 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 {
9841 wxString const &_result_ref = (arg1)->GetAnchor();
9842 result = (wxString *) &_result_ref;
9843 }
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 {
9848 #if wxUSE_UNICODE
9849 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9850 #else
9851 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9852 #endif
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9861 PyObject *resultobj = 0;
9862 wxFSFile *arg1 = (wxFSFile *) 0 ;
9863 wxDateTime result;
9864 void *argp1 = 0 ;
9865 int res1 = 0 ;
9866 PyObject *swig_obj[1] ;
9867
9868 if (!args) SWIG_fail;
9869 swig_obj[0] = args;
9870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9871 if (!SWIG_IsOK(res1)) {
9872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9873 }
9874 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = (arg1)->GetModificationTime();
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9889 PyObject *obj;
9890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9891 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9892 return SWIG_Py_Void();
9893 }
9894
9895 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 return SWIG_Python_InitShadowInstance(args);
9897 }
9898
9899 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9900 PyObject *resultobj = 0;
9901 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9902 void *argp1 = 0 ;
9903 int res1 = 0 ;
9904 PyObject *swig_obj[1] ;
9905
9906 if (!args) SWIG_fail;
9907 swig_obj[0] = args;
9908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9911 }
9912 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 delete arg1;
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 resultobj = SWIG_Py_Void();
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9928 PyObject *obj;
9929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9930 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9931 return SWIG_Py_Void();
9932 }
9933
9934 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935 PyObject *resultobj = 0;
9936 wxPyFileSystemHandler *result = 0 ;
9937
9938 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9955 PyObject *arg2 = (PyObject *) 0 ;
9956 PyObject *arg3 = (PyObject *) 0 ;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 PyObject * obj2 = 0 ;
9962 char * kwnames[] = {
9963 (char *) "self",(char *) "self",(char *) "_class", NULL
9964 };
9965
9966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9968 if (!SWIG_IsOK(res1)) {
9969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9970 }
9971 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9972 arg2 = obj1;
9973 arg3 = obj2;
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 (arg1)->_setCallbackInfo(arg2,arg3);
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_Py_Void();
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj = 0;
9989 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9990 wxString *arg2 = 0 ;
9991 bool result;
9992 void *argp1 = 0 ;
9993 int res1 = 0 ;
9994 bool temp2 = false ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 char * kwnames[] = {
9998 (char *) "self",(char *) "location", NULL
9999 };
10000
10001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10003 if (!SWIG_IsOK(res1)) {
10004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10005 }
10006 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10007 {
10008 arg2 = wxString_in_helper(obj1);
10009 if (arg2 == NULL) SWIG_fail;
10010 temp2 = true;
10011 }
10012 {
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 {
10019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10020 }
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return resultobj;
10026 fail:
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return NULL;
10032 }
10033
10034
10035 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj = 0;
10037 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10038 wxFileSystem *arg2 = 0 ;
10039 wxString *arg3 = 0 ;
10040 wxFSFile *result = 0 ;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 void *argp2 = 0 ;
10044 int res2 = 0 ;
10045 bool temp3 = false ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 PyObject * obj2 = 0 ;
10049 char * kwnames[] = {
10050 (char *) "self",(char *) "fs",(char *) "location", NULL
10051 };
10052
10053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10055 if (!SWIG_IsOK(res1)) {
10056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10057 }
10058 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10060 if (!SWIG_IsOK(res2)) {
10061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10062 }
10063 if (!argp2) {
10064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10065 }
10066 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10067 {
10068 arg3 = wxString_in_helper(obj2);
10069 if (arg3 == NULL) SWIG_fail;
10070 temp3 = true;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10080 }
10081 {
10082 if (temp3)
10083 delete arg3;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10098 wxString *arg2 = 0 ;
10099 int arg3 = (int) 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 bool temp2 = false ;
10104 int val3 ;
10105 int ecode3 = 0 ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 PyObject * obj2 = 0 ;
10109 char * kwnames[] = {
10110 (char *) "self",(char *) "spec",(char *) "flags", NULL
10111 };
10112
10113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10117 }
10118 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 if (obj2) {
10125 ecode3 = SWIG_AsVal_int(obj2, &val3);
10126 if (!SWIG_IsOK(ecode3)) {
10127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10128 }
10129 arg3 = static_cast< int >(val3);
10130 }
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 {
10138 #if wxUSE_UNICODE
10139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10140 #else
10141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10142 #endif
10143 }
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10159 PyObject *resultobj = 0;
10160 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10161 wxString result;
10162 void *argp1 = 0 ;
10163 int res1 = 0 ;
10164 PyObject *swig_obj[1] ;
10165
10166 if (!args) SWIG_fail;
10167 swig_obj[0] = args;
10168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10169 if (!SWIG_IsOK(res1)) {
10170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10171 }
10172 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->FindNext();
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10193 PyObject *resultobj = 0;
10194 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10195 wxString *arg2 = 0 ;
10196 wxString result;
10197 void *argp1 = 0 ;
10198 int res1 = 0 ;
10199 bool temp2 = false ;
10200 PyObject * obj0 = 0 ;
10201 PyObject * obj1 = 0 ;
10202 char * kwnames[] = {
10203 (char *) "self",(char *) "location", NULL
10204 };
10205
10206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10208 if (!SWIG_IsOK(res1)) {
10209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10210 }
10211 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10212 {
10213 arg2 = wxString_in_helper(obj1);
10214 if (arg2 == NULL) SWIG_fail;
10215 temp2 = true;
10216 }
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 result = (arg1)->GetProtocol((wxString const &)*arg2);
10220 wxPyEndAllowThreads(__tstate);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 {
10224 #if wxUSE_UNICODE
10225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10226 #else
10227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10228 #endif
10229 }
10230 {
10231 if (temp2)
10232 delete arg2;
10233 }
10234 return resultobj;
10235 fail:
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return NULL;
10241 }
10242
10243
10244 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj = 0;
10246 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10247 wxString *arg2 = 0 ;
10248 wxString result;
10249 void *argp1 = 0 ;
10250 int res1 = 0 ;
10251 bool temp2 = false ;
10252 PyObject * obj0 = 0 ;
10253 PyObject * obj1 = 0 ;
10254 char * kwnames[] = {
10255 (char *) "self",(char *) "location", NULL
10256 };
10257
10258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10260 if (!SWIG_IsOK(res1)) {
10261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10262 }
10263 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 {
10276 #if wxUSE_UNICODE
10277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10278 #else
10279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10280 #endif
10281 }
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj = 0;
10298 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10299 wxString *arg2 = 0 ;
10300 wxString result;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 bool temp2 = false ;
10304 PyObject * obj0 = 0 ;
10305 PyObject * obj1 = 0 ;
10306 char * kwnames[] = {
10307 (char *) "self",(char *) "location", NULL
10308 };
10309
10310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10316 {
10317 arg2 = wxString_in_helper(obj1);
10318 if (arg2 == NULL) SWIG_fail;
10319 temp2 = true;
10320 }
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (arg1)->GetAnchor((wxString const &)*arg2);
10324 wxPyEndAllowThreads(__tstate);
10325 if (PyErr_Occurred()) SWIG_fail;
10326 }
10327 {
10328 #if wxUSE_UNICODE
10329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10330 #else
10331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10332 #endif
10333 }
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj = 0;
10350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10351 wxString *arg2 = 0 ;
10352 wxString result;
10353 void *argp1 = 0 ;
10354 int res1 = 0 ;
10355 bool temp2 = false ;
10356 PyObject * obj0 = 0 ;
10357 PyObject * obj1 = 0 ;
10358 char * kwnames[] = {
10359 (char *) "self",(char *) "location", NULL
10360 };
10361
10362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10364 if (!SWIG_IsOK(res1)) {
10365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10366 }
10367 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10368 {
10369 arg2 = wxString_in_helper(obj1);
10370 if (arg2 == NULL) SWIG_fail;
10371 temp2 = true;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 {
10380 #if wxUSE_UNICODE
10381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10382 #else
10383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10384 #endif
10385 }
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return resultobj;
10391 fail:
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10403 wxString *arg2 = 0 ;
10404 wxString result;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 bool temp2 = false ;
10408 PyObject * obj0 = 0 ;
10409 PyObject * obj1 = 0 ;
10410 char * kwnames[] = {
10411 (char *) "self",(char *) "location", NULL
10412 };
10413
10414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10416 if (!SWIG_IsOK(res1)) {
10417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10418 }
10419 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10420 {
10421 arg2 = wxString_in_helper(obj1);
10422 if (arg2 == NULL) SWIG_fail;
10423 temp2 = true;
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 #if wxUSE_UNICODE
10433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10434 #else
10435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10436 #endif
10437 }
10438 {
10439 if (temp2)
10440 delete arg2;
10441 }
10442 return resultobj;
10443 fail:
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return NULL;
10449 }
10450
10451
10452 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10453 PyObject *obj;
10454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10455 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10456 return SWIG_Py_Void();
10457 }
10458
10459 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10460 return SWIG_Python_InitShadowInstance(args);
10461 }
10462
10463 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10464 PyObject *resultobj = 0;
10465 wxFileSystem *result = 0 ;
10466
10467 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 result = (wxFileSystem *)new wxFileSystem();
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10484 PyObject *resultobj = 0;
10485 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10486 void *argp1 = 0 ;
10487 int res1 = 0 ;
10488 PyObject *swig_obj[1] ;
10489
10490 if (!args) SWIG_fail;
10491 swig_obj[0] = args;
10492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10493 if (!SWIG_IsOK(res1)) {
10494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10495 }
10496 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 delete arg1;
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_Py_Void();
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10512 PyObject *resultobj = 0;
10513 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10514 wxString *arg2 = 0 ;
10515 bool arg3 = (bool) false ;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 bool temp2 = false ;
10519 bool val3 ;
10520 int ecode3 = 0 ;
10521 PyObject * obj0 = 0 ;
10522 PyObject * obj1 = 0 ;
10523 PyObject * obj2 = 0 ;
10524 char * kwnames[] = {
10525 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10526 };
10527
10528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10530 if (!SWIG_IsOK(res1)) {
10531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10532 }
10533 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 if (obj2) {
10540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10541 if (!SWIG_IsOK(ecode3)) {
10542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10543 }
10544 arg3 = static_cast< bool >(val3);
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_Py_Void();
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10570 wxString result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10580 }
10581 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (arg1)->GetPath();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 #if wxUSE_UNICODE
10590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10591 #else
10592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10593 #endif
10594 }
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj = 0;
10603 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10604 wxString *arg2 = 0 ;
10605 wxFSFile *result = 0 ;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 bool temp2 = false ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611 char * kwnames[] = {
10612 (char *) "self",(char *) "location", NULL
10613 };
10614
10615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10619 }
10620 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10621 {
10622 arg2 = wxString_in_helper(obj1);
10623 if (arg2 == NULL) SWIG_fail;
10624 temp2 = true;
10625 }
10626 {
10627 PyThreadState* __tstate = wxPyBeginAllowThreads();
10628 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 {
10633 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10634 }
10635 {
10636 if (temp2)
10637 delete arg2;
10638 }
10639 return resultobj;
10640 fail:
10641 {
10642 if (temp2)
10643 delete arg2;
10644 }
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10650 PyObject *resultobj = 0;
10651 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10652 wxString *arg2 = 0 ;
10653 int arg3 = (int) 0 ;
10654 wxString result;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 bool temp2 = false ;
10658 int val3 ;
10659 int ecode3 = 0 ;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 PyObject * obj2 = 0 ;
10663 char * kwnames[] = {
10664 (char *) "self",(char *) "spec",(char *) "flags", NULL
10665 };
10666
10667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10669 if (!SWIG_IsOK(res1)) {
10670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10671 }
10672 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10673 {
10674 arg2 = wxString_in_helper(obj1);
10675 if (arg2 == NULL) SWIG_fail;
10676 temp2 = true;
10677 }
10678 if (obj2) {
10679 ecode3 = SWIG_AsVal_int(obj2, &val3);
10680 if (!SWIG_IsOK(ecode3)) {
10681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10682 }
10683 arg3 = static_cast< int >(val3);
10684 }
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 {
10692 #if wxUSE_UNICODE
10693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10694 #else
10695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10696 #endif
10697 }
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return resultobj;
10703 fail:
10704 {
10705 if (temp2)
10706 delete arg2;
10707 }
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10713 PyObject *resultobj = 0;
10714 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10715 wxString result;
10716 void *argp1 = 0 ;
10717 int res1 = 0 ;
10718 PyObject *swig_obj[1] ;
10719
10720 if (!args) SWIG_fail;
10721 swig_obj[0] = args;
10722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10723 if (!SWIG_IsOK(res1)) {
10724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10725 }
10726 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (arg1)->FindNext();
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 #if wxUSE_UNICODE
10735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10736 #else
10737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10738 #endif
10739 }
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj = 0;
10748 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10749 int res1 = 0 ;
10750 PyObject * obj0 = 0 ;
10751 char * kwnames[] = {
10752 (char *) "handler", NULL
10753 };
10754
10755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10756 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10757 if (!SWIG_IsOK(res1)) {
10758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10759 }
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 wxFileSystem::AddHandler(arg1);
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_Py_Void();
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10774 PyObject *resultobj = 0;
10775
10776 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 wxFileSystem::CleanUpHandlers();
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 resultobj = SWIG_Py_Void();
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10791 PyObject *resultobj = 0;
10792 wxString *arg1 = 0 ;
10793 wxString result;
10794 bool temp1 = false ;
10795 PyObject * obj0 = 0 ;
10796 char * kwnames[] = {
10797 (char *) "filename", NULL
10798 };
10799
10800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10801 {
10802 arg1 = wxString_in_helper(obj0);
10803 if (arg1 == NULL) SWIG_fail;
10804 temp1 = true;
10805 }
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 {
10813 #if wxUSE_UNICODE
10814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10815 #else
10816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10817 #endif
10818 }
10819 {
10820 if (temp1)
10821 delete arg1;
10822 }
10823 return resultobj;
10824 fail:
10825 {
10826 if (temp1)
10827 delete arg1;
10828 }
10829 return NULL;
10830 }
10831
10832
10833 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj = 0;
10835 wxString *arg1 = 0 ;
10836 wxString result;
10837 bool temp1 = false ;
10838 PyObject * obj0 = 0 ;
10839 char * kwnames[] = {
10840 (char *) "url", NULL
10841 };
10842
10843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10844 {
10845 arg1 = wxString_in_helper(obj0);
10846 if (arg1 == NULL) SWIG_fail;
10847 temp1 = true;
10848 }
10849 {
10850 PyThreadState* __tstate = wxPyBeginAllowThreads();
10851 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 #if wxUSE_UNICODE
10857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10858 #else
10859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10860 #endif
10861 }
10862 {
10863 if (temp1)
10864 delete arg1;
10865 }
10866 return resultobj;
10867 fail:
10868 {
10869 if (temp1)
10870 delete arg1;
10871 }
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10877 PyObject *obj;
10878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10879 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10880 return SWIG_Py_Void();
10881 }
10882
10883 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10884 return SWIG_Python_InitShadowInstance(args);
10885 }
10886
10887 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10888 PyObject *resultobj = 0;
10889 wxInternetFSHandler *result = 0 ;
10890
10891 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10908 wxString *arg2 = 0 ;
10909 bool result;
10910 void *argp1 = 0 ;
10911 int res1 = 0 ;
10912 bool temp2 = false ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 char * kwnames[] = {
10916 (char *) "self",(char *) "location", NULL
10917 };
10918
10919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10921 if (!SWIG_IsOK(res1)) {
10922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10923 }
10924 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10925 {
10926 arg2 = wxString_in_helper(obj1);
10927 if (arg2 == NULL) SWIG_fail;
10928 temp2 = true;
10929 }
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 {
10937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10938 }
10939 {
10940 if (temp2)
10941 delete arg2;
10942 }
10943 return resultobj;
10944 fail:
10945 {
10946 if (temp2)
10947 delete arg2;
10948 }
10949 return NULL;
10950 }
10951
10952
10953 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj = 0;
10955 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10956 wxFileSystem *arg2 = 0 ;
10957 wxString *arg3 = 0 ;
10958 wxFSFile *result = 0 ;
10959 void *argp1 = 0 ;
10960 int res1 = 0 ;
10961 void *argp2 = 0 ;
10962 int res2 = 0 ;
10963 bool temp3 = false ;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 PyObject * obj2 = 0 ;
10967 char * kwnames[] = {
10968 (char *) "self",(char *) "fs",(char *) "location", NULL
10969 };
10970
10971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10973 if (!SWIG_IsOK(res1)) {
10974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10975 }
10976 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10978 if (!SWIG_IsOK(res2)) {
10979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10980 }
10981 if (!argp2) {
10982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10983 }
10984 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10985 {
10986 arg3 = wxString_in_helper(obj2);
10987 if (arg3 == NULL) SWIG_fail;
10988 temp3 = true;
10989 }
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10993 wxPyEndAllowThreads(__tstate);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 {
10997 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10998 }
10999 {
11000 if (temp3)
11001 delete arg3;
11002 }
11003 return resultobj;
11004 fail:
11005 {
11006 if (temp3)
11007 delete arg3;
11008 }
11009 return NULL;
11010 }
11011
11012
11013 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11014 PyObject *obj;
11015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11016 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11017 return SWIG_Py_Void();
11018 }
11019
11020 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11021 return SWIG_Python_InitShadowInstance(args);
11022 }
11023
11024 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11025 PyObject *resultobj = 0;
11026 wxZipFSHandler *result = 0 ;
11027
11028 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 result = (wxZipFSHandler *)new wxZipFSHandler();
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = 0;
11044 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11045 wxString *arg2 = 0 ;
11046 bool result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 bool temp2 = false ;
11050 PyObject * obj0 = 0 ;
11051 PyObject * obj1 = 0 ;
11052 char * kwnames[] = {
11053 (char *) "self",(char *) "location", NULL
11054 };
11055
11056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11058 if (!SWIG_IsOK(res1)) {
11059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11060 }
11061 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11062 {
11063 arg2 = wxString_in_helper(obj1);
11064 if (arg2 == NULL) SWIG_fail;
11065 temp2 = true;
11066 }
11067 {
11068 PyThreadState* __tstate = wxPyBeginAllowThreads();
11069 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 {
11074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11075 }
11076 {
11077 if (temp2)
11078 delete arg2;
11079 }
11080 return resultobj;
11081 fail:
11082 {
11083 if (temp2)
11084 delete arg2;
11085 }
11086 return NULL;
11087 }
11088
11089
11090 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj = 0;
11092 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11093 wxFileSystem *arg2 = 0 ;
11094 wxString *arg3 = 0 ;
11095 wxFSFile *result = 0 ;
11096 void *argp1 = 0 ;
11097 int res1 = 0 ;
11098 void *argp2 = 0 ;
11099 int res2 = 0 ;
11100 bool temp3 = false ;
11101 PyObject * obj0 = 0 ;
11102 PyObject * obj1 = 0 ;
11103 PyObject * obj2 = 0 ;
11104 char * kwnames[] = {
11105 (char *) "self",(char *) "fs",(char *) "location", NULL
11106 };
11107
11108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11110 if (!SWIG_IsOK(res1)) {
11111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11112 }
11113 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11115 if (!SWIG_IsOK(res2)) {
11116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11117 }
11118 if (!argp2) {
11119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11120 }
11121 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11122 {
11123 arg3 = wxString_in_helper(obj2);
11124 if (arg3 == NULL) SWIG_fail;
11125 temp3 = true;
11126 }
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 {
11134 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11135 }
11136 {
11137 if (temp3)
11138 delete arg3;
11139 }
11140 return resultobj;
11141 fail:
11142 {
11143 if (temp3)
11144 delete arg3;
11145 }
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj = 0;
11152 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11153 wxString *arg2 = 0 ;
11154 int arg3 = (int) 0 ;
11155 wxString result;
11156 void *argp1 = 0 ;
11157 int res1 = 0 ;
11158 bool temp2 = false ;
11159 int val3 ;
11160 int ecode3 = 0 ;
11161 PyObject * obj0 = 0 ;
11162 PyObject * obj1 = 0 ;
11163 PyObject * obj2 = 0 ;
11164 char * kwnames[] = {
11165 (char *) "self",(char *) "spec",(char *) "flags", NULL
11166 };
11167
11168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11172 }
11173 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11174 {
11175 arg2 = wxString_in_helper(obj1);
11176 if (arg2 == NULL) SWIG_fail;
11177 temp2 = true;
11178 }
11179 if (obj2) {
11180 ecode3 = SWIG_AsVal_int(obj2, &val3);
11181 if (!SWIG_IsOK(ecode3)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11183 }
11184 arg3 = static_cast< int >(val3);
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 {
11193 #if wxUSE_UNICODE
11194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11195 #else
11196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11197 #endif
11198 }
11199 {
11200 if (temp2)
11201 delete arg2;
11202 }
11203 return resultobj;
11204 fail:
11205 {
11206 if (temp2)
11207 delete arg2;
11208 }
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11214 PyObject *resultobj = 0;
11215 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11216 wxString result;
11217 void *argp1 = 0 ;
11218 int res1 = 0 ;
11219 PyObject *swig_obj[1] ;
11220
11221 if (!args) SWIG_fail;
11222 swig_obj[0] = args;
11223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11224 if (!SWIG_IsOK(res1)) {
11225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11226 }
11227 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = (arg1)->FindNext();
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 return resultobj;
11242 fail:
11243 return NULL;
11244 }
11245
11246
11247 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11248 PyObject *obj;
11249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11250 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11251 return SWIG_Py_Void();
11252 }
11253
11254 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11255 return SWIG_Python_InitShadowInstance(args);
11256 }
11257
11258 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxString *arg1 = 0 ;
11261 wxImage *arg2 = 0 ;
11262 long arg3 ;
11263 bool temp1 = false ;
11264 void *argp2 = 0 ;
11265 int res2 = 0 ;
11266 long val3 ;
11267 int ecode3 = 0 ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 PyObject * obj2 = 0 ;
11271 char * kwnames[] = {
11272 (char *) "filename",(char *) "image",(char *) "type", NULL
11273 };
11274
11275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11276 {
11277 arg1 = wxString_in_helper(obj0);
11278 if (arg1 == NULL) SWIG_fail;
11279 temp1 = true;
11280 }
11281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11282 if (!SWIG_IsOK(res2)) {
11283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11284 }
11285 if (!argp2) {
11286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11287 }
11288 arg2 = reinterpret_cast< wxImage * >(argp2);
11289 ecode3 = SWIG_AsVal_long(obj2, &val3);
11290 if (!SWIG_IsOK(ecode3)) {
11291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11292 }
11293 arg3 = static_cast< long >(val3);
11294 {
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 resultobj = SWIG_Py_Void();
11301 {
11302 if (temp1)
11303 delete arg1;
11304 }
11305 return resultobj;
11306 fail:
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return NULL;
11312 }
11313
11314
11315 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj = 0;
11317 wxString *arg1 = 0 ;
11318 wxBitmap *arg2 = 0 ;
11319 long arg3 ;
11320 bool temp1 = false ;
11321 void *argp2 = 0 ;
11322 int res2 = 0 ;
11323 long val3 ;
11324 int ecode3 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 {
11334 arg1 = wxString_in_helper(obj0);
11335 if (arg1 == NULL) SWIG_fail;
11336 temp1 = true;
11337 }
11338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11341 }
11342 if (!argp2) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11344 }
11345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11346 ecode3 = SWIG_AsVal_long(obj2, &val3);
11347 if (!SWIG_IsOK(ecode3)) {
11348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11349 }
11350 arg3 = static_cast< long >(val3);
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxString *arg1 = 0 ;
11375 PyObject *arg2 = (PyObject *) 0 ;
11376 bool temp1 = false ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 char * kwnames[] = {
11380 (char *) "filename",(char *) "data", NULL
11381 };
11382
11383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11384 {
11385 arg1 = wxString_in_helper(obj0);
11386 if (arg1 == NULL) SWIG_fail;
11387 temp1 = true;
11388 }
11389 arg2 = obj1;
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 resultobj = SWIG_Py_Void();
11397 {
11398 if (temp1)
11399 delete arg1;
11400 }
11401 return resultobj;
11402 fail:
11403 {
11404 if (temp1)
11405 delete arg1;
11406 }
11407 return NULL;
11408 }
11409
11410
11411 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11412 PyObject *resultobj = 0;
11413 wxMemoryFSHandler *result = 0 ;
11414
11415 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 bool temp1 = false ;
11433 PyObject * obj0 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "filename", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11439 {
11440 arg1 = wxString_in_helper(obj0);
11441 if (arg1 == NULL) SWIG_fail;
11442 temp1 = true;
11443 }
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 resultobj = SWIG_Py_Void();
11451 {
11452 if (temp1)
11453 delete arg1;
11454 }
11455 return resultobj;
11456 fail:
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return NULL;
11462 }
11463
11464
11465 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj = 0;
11467 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11468 wxString *arg2 = 0 ;
11469 bool result;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 bool temp2 = false ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "self",(char *) "location", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11481 if (!SWIG_IsOK(res1)) {
11482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11483 }
11484 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11485 {
11486 arg2 = wxString_in_helper(obj1);
11487 if (arg2 == NULL) SWIG_fail;
11488 temp2 = true;
11489 }
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11498 }
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return resultobj;
11504 fail:
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return NULL;
11510 }
11511
11512
11513 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11514 PyObject *resultobj = 0;
11515 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11516 wxFileSystem *arg2 = 0 ;
11517 wxString *arg3 = 0 ;
11518 wxFSFile *result = 0 ;
11519 void *argp1 = 0 ;
11520 int res1 = 0 ;
11521 void *argp2 = 0 ;
11522 int res2 = 0 ;
11523 bool temp3 = false ;
11524 PyObject * obj0 = 0 ;
11525 PyObject * obj1 = 0 ;
11526 PyObject * obj2 = 0 ;
11527 char * kwnames[] = {
11528 (char *) "self",(char *) "fs",(char *) "location", NULL
11529 };
11530
11531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11533 if (!SWIG_IsOK(res1)) {
11534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11535 }
11536 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11538 if (!SWIG_IsOK(res2)) {
11539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11540 }
11541 if (!argp2) {
11542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11543 }
11544 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11545 {
11546 arg3 = wxString_in_helper(obj2);
11547 if (arg3 == NULL) SWIG_fail;
11548 temp3 = true;
11549 }
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11558 }
11559 {
11560 if (temp3)
11561 delete arg3;
11562 }
11563 return resultobj;
11564 fail:
11565 {
11566 if (temp3)
11567 delete arg3;
11568 }
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj = 0;
11575 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11576 wxString *arg2 = 0 ;
11577 int arg3 = (int) 0 ;
11578 wxString result;
11579 void *argp1 = 0 ;
11580 int res1 = 0 ;
11581 bool temp2 = false ;
11582 int val3 ;
11583 int ecode3 = 0 ;
11584 PyObject * obj0 = 0 ;
11585 PyObject * obj1 = 0 ;
11586 PyObject * obj2 = 0 ;
11587 char * kwnames[] = {
11588 (char *) "self",(char *) "spec",(char *) "flags", NULL
11589 };
11590
11591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11593 if (!SWIG_IsOK(res1)) {
11594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11595 }
11596 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11597 {
11598 arg2 = wxString_in_helper(obj1);
11599 if (arg2 == NULL) SWIG_fail;
11600 temp2 = true;
11601 }
11602 if (obj2) {
11603 ecode3 = SWIG_AsVal_int(obj2, &val3);
11604 if (!SWIG_IsOK(ecode3)) {
11605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11606 }
11607 arg3 = static_cast< int >(val3);
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 {
11616 #if wxUSE_UNICODE
11617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11618 #else
11619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11620 #endif
11621 }
11622 {
11623 if (temp2)
11624 delete arg2;
11625 }
11626 return resultobj;
11627 fail:
11628 {
11629 if (temp2)
11630 delete arg2;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11639 wxString result;
11640 void *argp1 = 0 ;
11641 int res1 = 0 ;
11642 PyObject *swig_obj[1] ;
11643
11644 if (!args) SWIG_fail;
11645 swig_obj[0] = args;
11646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11649 }
11650 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (arg1)->FindNext();
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 #if wxUSE_UNICODE
11659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11660 #else
11661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11662 #endif
11663 }
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *obj;
11672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11673 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11674 return SWIG_Py_Void();
11675 }
11676
11677 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 return SWIG_Python_InitShadowInstance(args);
11679 }
11680
11681 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11682 PyObject *resultobj = 0;
11683 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11684 wxString result;
11685 void *argp1 = 0 ;
11686 int res1 = 0 ;
11687 PyObject *swig_obj[1] ;
11688
11689 if (!args) SWIG_fail;
11690 swig_obj[0] = args;
11691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11692 if (!SWIG_IsOK(res1)) {
11693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11694 }
11695 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (arg1)->GetName();
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 {
11703 #if wxUSE_UNICODE
11704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11705 #else
11706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11707 #endif
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *resultobj = 0;
11717 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11718 wxString result;
11719 void *argp1 = 0 ;
11720 int res1 = 0 ;
11721 PyObject *swig_obj[1] ;
11722
11723 if (!args) SWIG_fail;
11724 swig_obj[0] = args;
11725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11726 if (!SWIG_IsOK(res1)) {
11727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11728 }
11729 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 result = (arg1)->GetExtension();
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 #if wxUSE_UNICODE
11738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11739 #else
11740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11741 #endif
11742 }
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11750 PyObject *resultobj = 0;
11751 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11752 long result;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 PyObject *swig_obj[1] ;
11756
11757 if (!args) SWIG_fail;
11758 swig_obj[0] = args;
11759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11760 if (!SWIG_IsOK(res1)) {
11761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11762 }
11763 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (long)(arg1)->GetType();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 resultobj = SWIG_From_long(static_cast< long >(result));
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 PyObject *resultobj = 0;
11779 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11780 wxString result;
11781 void *argp1 = 0 ;
11782 int res1 = 0 ;
11783 PyObject *swig_obj[1] ;
11784
11785 if (!args) SWIG_fail;
11786 swig_obj[0] = args;
11787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11788 if (!SWIG_IsOK(res1)) {
11789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11790 }
11791 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11792 {
11793 PyThreadState* __tstate = wxPyBeginAllowThreads();
11794 result = (arg1)->GetMimeType();
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 #if wxUSE_UNICODE
11800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11801 #else
11802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11803 #endif
11804 }
11805 return resultobj;
11806 fail:
11807 return NULL;
11808 }
11809
11810
11811 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11812 PyObject *resultobj = 0;
11813 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11814 wxString *arg2 = 0 ;
11815 bool result;
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 *) "name", NULL
11823 };
11824
11825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",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_CanRead" "', 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 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11844 }
11845 {
11846 if (temp2)
11847 delete arg2;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (temp2)
11853 delete arg2;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj = 0;
11861 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11862 wxString *arg2 = 0 ;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 bool temp2 = false ;
11866 PyObject * obj0 = 0 ;
11867 PyObject * obj1 = 0 ;
11868 char * kwnames[] = {
11869 (char *) "self",(char *) "name", NULL
11870 };
11871
11872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11876 }
11877 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11878 {
11879 arg2 = wxString_in_helper(obj1);
11880 if (arg2 == NULL) SWIG_fail;
11881 temp2 = true;
11882 }
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 (arg1)->SetName((wxString const &)*arg2);
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 resultobj = SWIG_Py_Void();
11890 {
11891 if (temp2)
11892 delete arg2;
11893 }
11894 return resultobj;
11895 fail:
11896 {
11897 if (temp2)
11898 delete arg2;
11899 }
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj = 0;
11906 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11907 wxString *arg2 = 0 ;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 bool temp2 = false ;
11911 PyObject * obj0 = 0 ;
11912 PyObject * obj1 = 0 ;
11913 char * kwnames[] = {
11914 (char *) "self",(char *) "extension", NULL
11915 };
11916
11917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11921 }
11922 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11923 {
11924 arg2 = wxString_in_helper(obj1);
11925 if (arg2 == NULL) SWIG_fail;
11926 temp2 = true;
11927 }
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 (arg1)->SetExtension((wxString const &)*arg2);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_Py_Void();
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return resultobj;
11940 fail:
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj = 0;
11951 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11952 long arg2 ;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955 long val2 ;
11956 int ecode2 = 0 ;
11957 PyObject * obj0 = 0 ;
11958 PyObject * obj1 = 0 ;
11959 char * kwnames[] = {
11960 (char *) "self",(char *) "type", NULL
11961 };
11962
11963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11965 if (!SWIG_IsOK(res1)) {
11966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11967 }
11968 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11969 ecode2 = SWIG_AsVal_long(obj1, &val2);
11970 if (!SWIG_IsOK(ecode2)) {
11971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11972 }
11973 arg2 = static_cast< long >(val2);
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 (arg1)->SetType(arg2);
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 resultobj = SWIG_Py_Void();
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj = 0;
11989 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11990 wxString *arg2 = 0 ;
11991 void *argp1 = 0 ;
11992 int res1 = 0 ;
11993 bool temp2 = false ;
11994 PyObject * obj0 = 0 ;
11995 PyObject * obj1 = 0 ;
11996 char * kwnames[] = {
11997 (char *) "self",(char *) "mimetype", NULL
11998 };
11999
12000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12002 if (!SWIG_IsOK(res1)) {
12003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12004 }
12005 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12006 {
12007 arg2 = wxString_in_helper(obj1);
12008 if (arg2 == NULL) SWIG_fail;
12009 temp2 = true;
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 (arg1)->SetMimeType((wxString const &)*arg2);
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_Py_Void();
12018 {
12019 if (temp2)
12020 delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *obj;
12034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12035 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12036 return SWIG_Py_Void();
12037 }
12038
12039 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12040 PyObject *resultobj = 0;
12041 wxPyImageHandler *result = 0 ;
12042
12043 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (wxPyImageHandler *)new wxPyImageHandler();
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj = 0;
12059 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12060 PyObject *arg2 = (PyObject *) 0 ;
12061 void *argp1 = 0 ;
12062 int res1 = 0 ;
12063 PyObject * obj0 = 0 ;
12064 PyObject * obj1 = 0 ;
12065 char * kwnames[] = {
12066 (char *) "self",(char *) "self", NULL
12067 };
12068
12069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12073 }
12074 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12075 arg2 = obj1;
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 (arg1)->_SetSelf(arg2);
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_Py_Void();
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *obj;
12091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12092 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12093 return SWIG_Py_Void();
12094 }
12095
12096 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12097 return SWIG_Python_InitShadowInstance(args);
12098 }
12099
12100 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *resultobj = 0;
12102 wxImageHistogram *result = 0 ;
12103
12104 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (wxImageHistogram *)new wxImageHistogram();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 byte arg1 ;
12121 byte arg2 ;
12122 byte arg3 ;
12123 unsigned long result;
12124 unsigned char val1 ;
12125 int ecode1 = 0 ;
12126 unsigned char val2 ;
12127 int ecode2 = 0 ;
12128 unsigned char val3 ;
12129 int ecode3 = 0 ;
12130 PyObject * obj0 = 0 ;
12131 PyObject * obj1 = 0 ;
12132 PyObject * obj2 = 0 ;
12133 char * kwnames[] = {
12134 (char *) "r",(char *) "g",(char *) "b", NULL
12135 };
12136
12137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12138 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12139 if (!SWIG_IsOK(ecode1)) {
12140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12141 }
12142 arg1 = static_cast< byte >(val1);
12143 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12144 if (!SWIG_IsOK(ecode2)) {
12145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12146 }
12147 arg2 = static_cast< byte >(val2);
12148 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12149 if (!SWIG_IsOK(ecode3)) {
12150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12151 }
12152 arg3 = static_cast< byte >(val3);
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12160 return resultobj;
12161 fail:
12162 return NULL;
12163 }
12164
12165
12166 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12167 PyObject *resultobj = 0;
12168 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12169 byte *arg2 = (byte *) 0 ;
12170 byte *arg3 = (byte *) 0 ;
12171 byte *arg4 = (byte *) 0 ;
12172 byte arg5 = (byte) 1 ;
12173 byte arg6 = (byte) 0 ;
12174 byte arg7 = (byte) 0 ;
12175 bool result;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 byte temp2 ;
12179 int res2 = SWIG_TMPOBJ ;
12180 byte temp3 ;
12181 int res3 = SWIG_TMPOBJ ;
12182 byte temp4 ;
12183 int res4 = SWIG_TMPOBJ ;
12184 unsigned char val5 ;
12185 int ecode5 = 0 ;
12186 unsigned char val6 ;
12187 int ecode6 = 0 ;
12188 unsigned char val7 ;
12189 int ecode7 = 0 ;
12190 PyObject * obj0 = 0 ;
12191 PyObject * obj1 = 0 ;
12192 PyObject * obj2 = 0 ;
12193 PyObject * obj3 = 0 ;
12194 char * kwnames[] = {
12195 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12196 };
12197
12198 arg2 = &temp2;
12199 arg3 = &temp3;
12200 arg4 = &temp4;
12201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12203 if (!SWIG_IsOK(res1)) {
12204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12205 }
12206 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12207 if (obj1) {
12208 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12209 if (!SWIG_IsOK(ecode5)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12211 }
12212 arg5 = static_cast< byte >(val5);
12213 }
12214 if (obj2) {
12215 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12216 if (!SWIG_IsOK(ecode6)) {
12217 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12218 }
12219 arg6 = static_cast< byte >(val6);
12220 }
12221 if (obj3) {
12222 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12223 if (!SWIG_IsOK(ecode7)) {
12224 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12225 }
12226 arg7 = static_cast< byte >(val7);
12227 }
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 {
12235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12236 }
12237 if (SWIG_IsTmpObj(res2)) {
12238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12239 } else {
12240 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12242 }
12243 if (SWIG_IsTmpObj(res3)) {
12244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12245 } else {
12246 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12248 }
12249 if (SWIG_IsTmpObj(res4)) {
12250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12251 } else {
12252 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12254 }
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj = 0;
12263 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12264 unsigned long arg2 ;
12265 unsigned long result;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 unsigned long val2 ;
12269 int ecode2 = 0 ;
12270 PyObject * obj0 = 0 ;
12271 PyObject * obj1 = 0 ;
12272 char * kwnames[] = {
12273 (char *) "self",(char *) "key", NULL
12274 };
12275
12276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12278 if (!SWIG_IsOK(res1)) {
12279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12280 }
12281 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12282 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12283 if (!SWIG_IsOK(ecode2)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12285 }
12286 arg2 = static_cast< unsigned long >(val2);
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = 0;
12302 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12303 byte arg2 ;
12304 byte arg3 ;
12305 byte arg4 ;
12306 unsigned long result;
12307 void *argp1 = 0 ;
12308 int res1 = 0 ;
12309 unsigned char val2 ;
12310 int ecode2 = 0 ;
12311 unsigned char val3 ;
12312 int ecode3 = 0 ;
12313 unsigned char val4 ;
12314 int ecode4 = 0 ;
12315 PyObject * obj0 = 0 ;
12316 PyObject * obj1 = 0 ;
12317 PyObject * obj2 = 0 ;
12318 PyObject * obj3 = 0 ;
12319 char * kwnames[] = {
12320 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12321 };
12322
12323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12325 if (!SWIG_IsOK(res1)) {
12326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12327 }
12328 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12329 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12330 if (!SWIG_IsOK(ecode2)) {
12331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12332 }
12333 arg2 = static_cast< byte >(val2);
12334 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12335 if (!SWIG_IsOK(ecode3)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12337 }
12338 arg3 = static_cast< byte >(val3);
12339 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12340 if (!SWIG_IsOK(ecode4)) {
12341 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12342 }
12343 arg4 = static_cast< byte >(val4);
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj = 0;
12359 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12360 wxColour *arg2 = 0 ;
12361 unsigned long result;
12362 void *argp1 = 0 ;
12363 int res1 = 0 ;
12364 wxColour temp2 ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 char * kwnames[] = {
12368 (char *) "self",(char *) "colour", NULL
12369 };
12370
12371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12373 if (!SWIG_IsOK(res1)) {
12374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12375 }
12376 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12377 {
12378 arg2 = &temp2;
12379 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12380 }
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12395 PyObject *obj;
12396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12397 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12398 return SWIG_Py_Void();
12399 }
12400
12401 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12402 return SWIG_Python_InitShadowInstance(args);
12403 }
12404
12405 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj = 0;
12407 byte arg1 = (byte) 0 ;
12408 byte arg2 = (byte) 0 ;
12409 byte arg3 = (byte) 0 ;
12410 wxImage_RGBValue *result = 0 ;
12411 unsigned char val1 ;
12412 int ecode1 = 0 ;
12413 unsigned char val2 ;
12414 int ecode2 = 0 ;
12415 unsigned char val3 ;
12416 int ecode3 = 0 ;
12417 PyObject * obj0 = 0 ;
12418 PyObject * obj1 = 0 ;
12419 PyObject * obj2 = 0 ;
12420 char * kwnames[] = {
12421 (char *) "r",(char *) "g",(char *) "b", NULL
12422 };
12423
12424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12425 if (obj0) {
12426 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12427 if (!SWIG_IsOK(ecode1)) {
12428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12429 }
12430 arg1 = static_cast< byte >(val1);
12431 }
12432 if (obj1) {
12433 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12434 if (!SWIG_IsOK(ecode2)) {
12435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12436 }
12437 arg2 = static_cast< byte >(val2);
12438 }
12439 if (obj2) {
12440 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12441 if (!SWIG_IsOK(ecode3)) {
12442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12443 }
12444 arg3 = static_cast< byte >(val3);
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12460 PyObject *resultobj = 0;
12461 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12462 byte arg2 ;
12463 void *argp1 = 0 ;
12464 int res1 = 0 ;
12465 unsigned char val2 ;
12466 int ecode2 = 0 ;
12467 PyObject *swig_obj[2] ;
12468
12469 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12471 if (!SWIG_IsOK(res1)) {
12472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12473 }
12474 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12475 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12476 if (!SWIG_IsOK(ecode2)) {
12477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12478 }
12479 arg2 = static_cast< byte >(val2);
12480 if (arg1) (arg1)->red = arg2;
12481
12482 resultobj = SWIG_Py_Void();
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12490 PyObject *resultobj = 0;
12491 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12492 byte result;
12493 void *argp1 = 0 ;
12494 int res1 = 0 ;
12495 PyObject *swig_obj[1] ;
12496
12497 if (!args) SWIG_fail;
12498 swig_obj[0] = args;
12499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12500 if (!SWIG_IsOK(res1)) {
12501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12502 }
12503 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12504 result = (byte) ((arg1)->red);
12505 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12513 PyObject *resultobj = 0;
12514 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12515 byte arg2 ;
12516 void *argp1 = 0 ;
12517 int res1 = 0 ;
12518 unsigned char val2 ;
12519 int ecode2 = 0 ;
12520 PyObject *swig_obj[2] ;
12521
12522 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12524 if (!SWIG_IsOK(res1)) {
12525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12526 }
12527 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12528 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12529 if (!SWIG_IsOK(ecode2)) {
12530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12531 }
12532 arg2 = static_cast< byte >(val2);
12533 if (arg1) (arg1)->green = arg2;
12534
12535 resultobj = SWIG_Py_Void();
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 PyObject *resultobj = 0;
12544 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12545 byte result;
12546 void *argp1 = 0 ;
12547 int res1 = 0 ;
12548 PyObject *swig_obj[1] ;
12549
12550 if (!args) SWIG_fail;
12551 swig_obj[0] = args;
12552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12553 if (!SWIG_IsOK(res1)) {
12554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12555 }
12556 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12557 result = (byte) ((arg1)->green);
12558 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *resultobj = 0;
12567 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12568 byte arg2 ;
12569 void *argp1 = 0 ;
12570 int res1 = 0 ;
12571 unsigned char val2 ;
12572 int ecode2 = 0 ;
12573 PyObject *swig_obj[2] ;
12574
12575 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12577 if (!SWIG_IsOK(res1)) {
12578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12579 }
12580 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12581 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12582 if (!SWIG_IsOK(ecode2)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12584 }
12585 arg2 = static_cast< byte >(val2);
12586 if (arg1) (arg1)->blue = arg2;
12587
12588 resultobj = SWIG_Py_Void();
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12596 PyObject *resultobj = 0;
12597 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12598 byte result;
12599 void *argp1 = 0 ;
12600 int res1 = 0 ;
12601 PyObject *swig_obj[1] ;
12602
12603 if (!args) SWIG_fail;
12604 swig_obj[0] = args;
12605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12606 if (!SWIG_IsOK(res1)) {
12607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12608 }
12609 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12610 result = (byte) ((arg1)->blue);
12611 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12612 return resultobj;
12613 fail:
12614 return NULL;
12615 }
12616
12617
12618 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12619 PyObject *obj;
12620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12621 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12622 return SWIG_Py_Void();
12623 }
12624
12625 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 return SWIG_Python_InitShadowInstance(args);
12627 }
12628
12629 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj = 0;
12631 double arg1 = (double) 0.0 ;
12632 double arg2 = (double) 0.0 ;
12633 double arg3 = (double) 0.0 ;
12634 wxImage_HSVValue *result = 0 ;
12635 double val1 ;
12636 int ecode1 = 0 ;
12637 double val2 ;
12638 int ecode2 = 0 ;
12639 double val3 ;
12640 int ecode3 = 0 ;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 PyObject * obj2 = 0 ;
12644 char * kwnames[] = {
12645 (char *) "h",(char *) "s",(char *) "v", NULL
12646 };
12647
12648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12649 if (obj0) {
12650 ecode1 = SWIG_AsVal_double(obj0, &val1);
12651 if (!SWIG_IsOK(ecode1)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12653 }
12654 arg1 = static_cast< double >(val1);
12655 }
12656 if (obj1) {
12657 ecode2 = SWIG_AsVal_double(obj1, &val2);
12658 if (!SWIG_IsOK(ecode2)) {
12659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12660 }
12661 arg2 = static_cast< double >(val2);
12662 }
12663 if (obj2) {
12664 ecode3 = SWIG_AsVal_double(obj2, &val3);
12665 if (!SWIG_IsOK(ecode3)) {
12666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12667 }
12668 arg3 = static_cast< double >(val3);
12669 }
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12686 double arg2 ;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 double val2 ;
12690 int ecode2 = 0 ;
12691 PyObject *swig_obj[2] ;
12692
12693 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12697 }
12698 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12699 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12702 }
12703 arg2 = static_cast< double >(val2);
12704 if (arg1) (arg1)->hue = arg2;
12705
12706 resultobj = SWIG_Py_Void();
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12714 PyObject *resultobj = 0;
12715 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12716 double result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject *swig_obj[1] ;
12720
12721 if (!args) SWIG_fail;
12722 swig_obj[0] = args;
12723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12724 if (!SWIG_IsOK(res1)) {
12725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12726 }
12727 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12728 result = (double) ((arg1)->hue);
12729 resultobj = SWIG_From_double(static_cast< double >(result));
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12739 double arg2 ;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 double val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12748 if (!SWIG_IsOK(res1)) {
12749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12750 }
12751 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12752 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12753 if (!SWIG_IsOK(ecode2)) {
12754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12755 }
12756 arg2 = static_cast< double >(val2);
12757 if (arg1) (arg1)->saturation = arg2;
12758
12759 resultobj = SWIG_Py_Void();
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12769 double result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 PyObject *swig_obj[1] ;
12773
12774 if (!args) SWIG_fail;
12775 swig_obj[0] = args;
12776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12779 }
12780 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12781 result = (double) ((arg1)->saturation);
12782 resultobj = SWIG_From_double(static_cast< double >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *resultobj = 0;
12791 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12792 double arg2 ;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 double val2 ;
12796 int ecode2 = 0 ;
12797 PyObject *swig_obj[2] ;
12798
12799 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12803 }
12804 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12805 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12806 if (!SWIG_IsOK(ecode2)) {
12807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12808 }
12809 arg2 = static_cast< double >(val2);
12810 if (arg1) (arg1)->value = arg2;
12811
12812 resultobj = SWIG_Py_Void();
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *resultobj = 0;
12821 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12822 double result;
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_HSVValue, 0 | 0 );
12830 if (!SWIG_IsOK(res1)) {
12831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12832 }
12833 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12834 result = (double) ((arg1)->value);
12835 resultobj = SWIG_From_double(static_cast< double >(result));
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12843 PyObject *obj;
12844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12845 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12846 return SWIG_Py_Void();
12847 }
12848
12849 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 return SWIG_Python_InitShadowInstance(args);
12851 }
12852
12853 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12854 PyObject *resultobj = 0;
12855 wxString *arg1 = 0 ;
12856 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12857 int arg3 = (int) -1 ;
12858 wxImage *result = 0 ;
12859 bool temp1 = false ;
12860 long val2 ;
12861 int ecode2 = 0 ;
12862 int val3 ;
12863 int ecode3 = 0 ;
12864 PyObject * obj0 = 0 ;
12865 PyObject * obj1 = 0 ;
12866 PyObject * obj2 = 0 ;
12867 char * kwnames[] = {
12868 (char *) "name",(char *) "type",(char *) "index", NULL
12869 };
12870
12871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12872 {
12873 arg1 = wxString_in_helper(obj0);
12874 if (arg1 == NULL) SWIG_fail;
12875 temp1 = true;
12876 }
12877 if (obj1) {
12878 ecode2 = SWIG_AsVal_long(obj1, &val2);
12879 if (!SWIG_IsOK(ecode2)) {
12880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12881 }
12882 arg2 = static_cast< long >(val2);
12883 }
12884 if (obj2) {
12885 ecode3 = SWIG_AsVal_int(obj2, &val3);
12886 if (!SWIG_IsOK(ecode3)) {
12887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12888 }
12889 arg3 = static_cast< int >(val3);
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12898 {
12899 if (temp1)
12900 delete arg1;
12901 }
12902 return resultobj;
12903 fail:
12904 {
12905 if (temp1)
12906 delete arg1;
12907 }
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxImage *arg1 = (wxImage *) 0 ;
12915 void *argp1 = 0 ;
12916 int res1 = 0 ;
12917 PyObject *swig_obj[1] ;
12918
12919 if (!args) SWIG_fail;
12920 swig_obj[0] = args;
12921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12922 if (!SWIG_IsOK(res1)) {
12923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12924 }
12925 arg1 = reinterpret_cast< wxImage * >(argp1);
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 delete arg1;
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 resultobj = SWIG_Py_Void();
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj = 0;
12942 wxString *arg1 = 0 ;
12943 wxString *arg2 = 0 ;
12944 int arg3 = (int) -1 ;
12945 wxImage *result = 0 ;
12946 bool temp1 = false ;
12947 bool temp2 = false ;
12948 int val3 ;
12949 int ecode3 = 0 ;
12950 PyObject * obj0 = 0 ;
12951 PyObject * obj1 = 0 ;
12952 PyObject * obj2 = 0 ;
12953 char * kwnames[] = {
12954 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12955 };
12956
12957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12958 {
12959 arg1 = wxString_in_helper(obj0);
12960 if (arg1 == NULL) SWIG_fail;
12961 temp1 = true;
12962 }
12963 {
12964 arg2 = wxString_in_helper(obj1);
12965 if (arg2 == NULL) SWIG_fail;
12966 temp2 = true;
12967 }
12968 if (obj2) {
12969 ecode3 = SWIG_AsVal_int(obj2, &val3);
12970 if (!SWIG_IsOK(ecode3)) {
12971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12972 }
12973 arg3 = static_cast< int >(val3);
12974 }
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12982 {
12983 if (temp1)
12984 delete arg1;
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991 fail:
12992 {
12993 if (temp1)
12994 delete arg1;
12995 }
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = 0;
13006 wxInputStream *arg1 = 0 ;
13007 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13008 int arg3 = (int) -1 ;
13009 wxImage *result = 0 ;
13010 wxPyInputStream *temp1 ;
13011 bool created1 ;
13012 long val2 ;
13013 int ecode2 = 0 ;
13014 int val3 ;
13015 int ecode3 = 0 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 PyObject * obj2 = 0 ;
13019 char * kwnames[] = {
13020 (char *) "stream",(char *) "type",(char *) "index", NULL
13021 };
13022
13023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13024 {
13025 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13026 arg1 = temp1->m_wxis;
13027 created1 = false;
13028 } else {
13029 PyErr_Clear(); // clear the failure of the wxPyConvert above
13030 arg1 = wxPyCBInputStream_create(obj0, false);
13031 if (arg1 == NULL) {
13032 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13033 SWIG_fail;
13034 }
13035 created1 = true;
13036 }
13037 }
13038 if (obj1) {
13039 ecode2 = SWIG_AsVal_long(obj1, &val2);
13040 if (!SWIG_IsOK(ecode2)) {
13041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13042 }
13043 arg2 = static_cast< long >(val2);
13044 }
13045 if (obj2) {
13046 ecode3 = SWIG_AsVal_int(obj2, &val3);
13047 if (!SWIG_IsOK(ecode3)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13049 }
13050 arg3 = static_cast< int >(val3);
13051 }
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13059 {
13060 if (created1) delete arg1;
13061 }
13062 return resultobj;
13063 fail:
13064 {
13065 if (created1) delete arg1;
13066 }
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = 0;
13073 wxInputStream *arg1 = 0 ;
13074 wxString *arg2 = 0 ;
13075 int arg3 = (int) -1 ;
13076 wxImage *result = 0 ;
13077 wxPyInputStream *temp1 ;
13078 bool created1 ;
13079 bool temp2 = false ;
13080 int val3 ;
13081 int ecode3 = 0 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 PyObject * obj2 = 0 ;
13085 char * kwnames[] = {
13086 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13087 };
13088
13089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13090 {
13091 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13092 arg1 = temp1->m_wxis;
13093 created1 = false;
13094 } else {
13095 PyErr_Clear(); // clear the failure of the wxPyConvert above
13096 arg1 = wxPyCBInputStream_create(obj0, false);
13097 if (arg1 == NULL) {
13098 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13099 SWIG_fail;
13100 }
13101 created1 = true;
13102 }
13103 }
13104 {
13105 arg2 = wxString_in_helper(obj1);
13106 if (arg2 == NULL) SWIG_fail;
13107 temp2 = true;
13108 }
13109 if (obj2) {
13110 ecode3 = SWIG_AsVal_int(obj2, &val3);
13111 if (!SWIG_IsOK(ecode3)) {
13112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13113 }
13114 arg3 = static_cast< int >(val3);
13115 }
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13123 {
13124 if (created1) delete arg1;
13125 }
13126 {
13127 if (temp2)
13128 delete arg2;
13129 }
13130 return resultobj;
13131 fail:
13132 {
13133 if (created1) delete arg1;
13134 }
13135 {
13136 if (temp2)
13137 delete arg2;
13138 }
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 int arg1 = (int) 0 ;
13146 int arg2 = (int) 0 ;
13147 bool arg3 = (bool) true ;
13148 wxImage *result = 0 ;
13149 int val1 ;
13150 int ecode1 = 0 ;
13151 int val2 ;
13152 int ecode2 = 0 ;
13153 bool val3 ;
13154 int ecode3 = 0 ;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 PyObject * obj2 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "width",(char *) "height",(char *) "clear", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13163 if (obj0) {
13164 ecode1 = SWIG_AsVal_int(obj0, &val1);
13165 if (!SWIG_IsOK(ecode1)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13167 }
13168 arg1 = static_cast< int >(val1);
13169 }
13170 if (obj1) {
13171 ecode2 = SWIG_AsVal_int(obj1, &val2);
13172 if (!SWIG_IsOK(ecode2)) {
13173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13174 }
13175 arg2 = static_cast< int >(val2);
13176 }
13177 if (obj2) {
13178 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13179 if (!SWIG_IsOK(ecode3)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13181 }
13182 arg3 = static_cast< bool >(val3);
13183 }
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj = 0;
13199 wxBitmap *arg1 = 0 ;
13200 wxImage *result = 0 ;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 PyObject * obj0 = 0 ;
13204 char * kwnames[] = {
13205 (char *) "bitmap", NULL
13206 };
13207
13208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13209 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13210 if (!SWIG_IsOK(res1)) {
13211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13212 }
13213 if (!argp1) {
13214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13215 }
13216 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13217 {
13218 if (!wxPyCheckForApp()) SWIG_fail;
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj = 0;
13233 int arg1 ;
13234 int arg2 ;
13235 buffer arg3 ;
13236 int arg4 ;
13237 wxImage *result = 0 ;
13238 int val1 ;
13239 int ecode1 = 0 ;
13240 int val2 ;
13241 int ecode2 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 PyObject * obj1 = 0 ;
13244 PyObject * obj2 = 0 ;
13245 char * kwnames[] = {
13246 (char *) "width",(char *) "height",(char *) "data", NULL
13247 };
13248
13249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13250 ecode1 = SWIG_AsVal_int(obj0, &val1);
13251 if (!SWIG_IsOK(ecode1)) {
13252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13253 }
13254 arg1 = static_cast< int >(val1);
13255 ecode2 = SWIG_AsVal_int(obj1, &val2);
13256 if (!SWIG_IsOK(ecode2)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13258 }
13259 arg2 = static_cast< int >(val2);
13260 {
13261 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13262 }
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj = 0;
13278 int arg1 ;
13279 int arg2 ;
13280 buffer arg3 ;
13281 int arg4 ;
13282 buffer arg5 ;
13283 int arg6 ;
13284 wxImage *result = 0 ;
13285 int val1 ;
13286 int ecode1 = 0 ;
13287 int val2 ;
13288 int ecode2 = 0 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 PyObject * obj3 = 0 ;
13293 char * kwnames[] = {
13294 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13295 };
13296
13297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13298 ecode1 = SWIG_AsVal_int(obj0, &val1);
13299 if (!SWIG_IsOK(ecode1)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13301 }
13302 arg1 = static_cast< int >(val1);
13303 ecode2 = SWIG_AsVal_int(obj1, &val2);
13304 if (!SWIG_IsOK(ecode2)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13306 }
13307 arg2 = static_cast< int >(val2);
13308 {
13309 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13310 }
13311 {
13312 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj = 0;
13329 wxImage *arg1 = (wxImage *) 0 ;
13330 int arg2 ;
13331 int arg3 ;
13332 bool arg4 = (bool) true ;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 int val2 ;
13336 int ecode2 = 0 ;
13337 int val3 ;
13338 int ecode3 = 0 ;
13339 bool val4 ;
13340 int ecode4 = 0 ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 PyObject * obj2 = 0 ;
13344 PyObject * obj3 = 0 ;
13345 char * kwnames[] = {
13346 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13347 };
13348
13349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13351 if (!SWIG_IsOK(res1)) {
13352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13353 }
13354 arg1 = reinterpret_cast< wxImage * >(argp1);
13355 ecode2 = SWIG_AsVal_int(obj1, &val2);
13356 if (!SWIG_IsOK(ecode2)) {
13357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13358 }
13359 arg2 = static_cast< int >(val2);
13360 ecode3 = SWIG_AsVal_int(obj2, &val3);
13361 if (!SWIG_IsOK(ecode3)) {
13362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13363 }
13364 arg3 = static_cast< int >(val3);
13365 if (obj3) {
13366 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13367 if (!SWIG_IsOK(ecode4)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13369 }
13370 arg4 = static_cast< bool >(val4);
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 (arg1)->Create(arg2,arg3,arg4);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_Py_Void();
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13386 PyObject *resultobj = 0;
13387 wxImage *arg1 = (wxImage *) 0 ;
13388 void *argp1 = 0 ;
13389 int res1 = 0 ;
13390 PyObject *swig_obj[1] ;
13391
13392 if (!args) SWIG_fail;
13393 swig_obj[0] = args;
13394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13395 if (!SWIG_IsOK(res1)) {
13396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13397 }
13398 arg1 = reinterpret_cast< wxImage * >(argp1);
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 (arg1)->Destroy();
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 resultobj = SWIG_Py_Void();
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj = 0;
13414 wxImage *arg1 = (wxImage *) 0 ;
13415 int arg2 ;
13416 int arg3 ;
13417 SwigValueWrapper<wxImage > result;
13418 void *argp1 = 0 ;
13419 int res1 = 0 ;
13420 int val2 ;
13421 int ecode2 = 0 ;
13422 int val3 ;
13423 int ecode3 = 0 ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 PyObject * obj2 = 0 ;
13427 char * kwnames[] = {
13428 (char *) "self",(char *) "width",(char *) "height", NULL
13429 };
13430
13431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13433 if (!SWIG_IsOK(res1)) {
13434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13435 }
13436 arg1 = reinterpret_cast< wxImage * >(argp1);
13437 ecode2 = SWIG_AsVal_int(obj1, &val2);
13438 if (!SWIG_IsOK(ecode2)) {
13439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13440 }
13441 arg2 = static_cast< int >(val2);
13442 ecode3 = SWIG_AsVal_int(obj2, &val3);
13443 if (!SWIG_IsOK(ecode3)) {
13444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13445 }
13446 arg3 = static_cast< int >(val3);
13447 {
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (arg1)->Scale(arg2,arg3);
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj = 0;
13462 wxImage *arg1 = (wxImage *) 0 ;
13463 int arg2 ;
13464 int arg3 ;
13465 SwigValueWrapper<wxImage > result;
13466 void *argp1 = 0 ;
13467 int res1 = 0 ;
13468 int val2 ;
13469 int ecode2 = 0 ;
13470 int val3 ;
13471 int ecode3 = 0 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 PyObject * obj2 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13481 if (!SWIG_IsOK(res1)) {
13482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13483 }
13484 arg1 = reinterpret_cast< wxImage * >(argp1);
13485 ecode2 = SWIG_AsVal_int(obj1, &val2);
13486 if (!SWIG_IsOK(ecode2)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13488 }
13489 arg2 = static_cast< int >(val2);
13490 ecode3 = SWIG_AsVal_int(obj2, &val3);
13491 if (!SWIG_IsOK(ecode3)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13493 }
13494 arg3 = static_cast< int >(val3);
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13502 return resultobj;
13503 fail:
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj = 0;
13510 wxImage *arg1 = (wxImage *) 0 ;
13511 int arg2 ;
13512 int arg3 ;
13513 wxImage *result = 0 ;
13514 void *argp1 = 0 ;
13515 int res1 = 0 ;
13516 int val2 ;
13517 int ecode2 = 0 ;
13518 int val3 ;
13519 int ecode3 = 0 ;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 PyObject * obj2 = 0 ;
13523 char * kwnames[] = {
13524 (char *) "self",(char *) "width",(char *) "height", NULL
13525 };
13526
13527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13529 if (!SWIG_IsOK(res1)) {
13530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13531 }
13532 arg1 = reinterpret_cast< wxImage * >(argp1);
13533 ecode2 = SWIG_AsVal_int(obj1, &val2);
13534 if (!SWIG_IsOK(ecode2)) {
13535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13536 }
13537 arg2 = static_cast< int >(val2);
13538 ecode3 = SWIG_AsVal_int(obj2, &val3);
13539 if (!SWIG_IsOK(ecode3)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13541 }
13542 arg3 = static_cast< int >(val3);
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 {
13546 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13547 result = (wxImage *) &_result_ref;
13548 }
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13560 PyObject *resultobj = 0;
13561 wxImage *arg1 = (wxImage *) 0 ;
13562 wxSize *arg2 = 0 ;
13563 wxPoint *arg3 = 0 ;
13564 int arg4 = (int) -1 ;
13565 int arg5 = (int) -1 ;
13566 int arg6 = (int) -1 ;
13567 wxImage *result = 0 ;
13568 void *argp1 = 0 ;
13569 int res1 = 0 ;
13570 wxSize temp2 ;
13571 wxPoint temp3 ;
13572 int val4 ;
13573 int ecode4 = 0 ;
13574 int val5 ;
13575 int ecode5 = 0 ;
13576 int val6 ;
13577 int ecode6 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 PyObject * obj4 = 0 ;
13583 PyObject * obj5 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13590 if (!SWIG_IsOK(res1)) {
13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13592 }
13593 arg1 = reinterpret_cast< wxImage * >(argp1);
13594 {
13595 arg2 = &temp2;
13596 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13597 }
13598 {
13599 arg3 = &temp3;
13600 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13601 }
13602 if (obj3) {
13603 ecode4 = SWIG_AsVal_int(obj3, &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13606 }
13607 arg4 = static_cast< int >(val4);
13608 }
13609 if (obj4) {
13610 ecode5 = SWIG_AsVal_int(obj4, &val5);
13611 if (!SWIG_IsOK(ecode5)) {
13612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13613 }
13614 arg5 = static_cast< int >(val5);
13615 }
13616 if (obj5) {
13617 ecode6 = SWIG_AsVal_int(obj5, &val6);
13618 if (!SWIG_IsOK(ecode6)) {
13619 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13620 }
13621 arg6 = static_cast< int >(val6);
13622 }
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 {
13626 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13627 result = (wxImage *) &_result_ref;
13628 }
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj = 0;
13641 wxImage *arg1 = (wxImage *) 0 ;
13642 int arg2 ;
13643 int arg3 ;
13644 byte arg4 ;
13645 byte arg5 ;
13646 byte arg6 ;
13647 void *argp1 = 0 ;
13648 int res1 = 0 ;
13649 int val2 ;
13650 int ecode2 = 0 ;
13651 int val3 ;
13652 int ecode3 = 0 ;
13653 unsigned char val4 ;
13654 int ecode4 = 0 ;
13655 unsigned char val5 ;
13656 int ecode5 = 0 ;
13657 unsigned char val6 ;
13658 int ecode6 = 0 ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 PyObject * obj2 = 0 ;
13662 PyObject * obj3 = 0 ;
13663 PyObject * obj4 = 0 ;
13664 PyObject * obj5 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13673 }
13674 arg1 = reinterpret_cast< wxImage * >(argp1);
13675 ecode2 = SWIG_AsVal_int(obj1, &val2);
13676 if (!SWIG_IsOK(ecode2)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13678 }
13679 arg2 = static_cast< int >(val2);
13680 ecode3 = SWIG_AsVal_int(obj2, &val3);
13681 if (!SWIG_IsOK(ecode3)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13683 }
13684 arg3 = static_cast< int >(val3);
13685 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13686 if (!SWIG_IsOK(ecode4)) {
13687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13688 }
13689 arg4 = static_cast< byte >(val4);
13690 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13691 if (!SWIG_IsOK(ecode5)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13693 }
13694 arg5 = static_cast< byte >(val5);
13695 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13696 if (!SWIG_IsOK(ecode6)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13698 }
13699 arg6 = static_cast< byte >(val6);
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 wxImage *arg1 = (wxImage *) 0 ;
13716 wxRect *arg2 = 0 ;
13717 byte arg3 ;
13718 byte arg4 ;
13719 byte arg5 ;
13720 void *argp1 = 0 ;
13721 int res1 = 0 ;
13722 wxRect temp2 ;
13723 unsigned char val3 ;
13724 int ecode3 = 0 ;
13725 unsigned char val4 ;
13726 int ecode4 = 0 ;
13727 unsigned char val5 ;
13728 int ecode5 = 0 ;
13729 PyObject * obj0 = 0 ;
13730 PyObject * obj1 = 0 ;
13731 PyObject * obj2 = 0 ;
13732 PyObject * obj3 = 0 ;
13733 PyObject * obj4 = 0 ;
13734 char * kwnames[] = {
13735 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13736 };
13737
13738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13740 if (!SWIG_IsOK(res1)) {
13741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13742 }
13743 arg1 = reinterpret_cast< wxImage * >(argp1);
13744 {
13745 arg2 = &temp2;
13746 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13747 }
13748 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13749 if (!SWIG_IsOK(ecode3)) {
13750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13751 }
13752 arg3 = static_cast< byte >(val3);
13753 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13754 if (!SWIG_IsOK(ecode4)) {
13755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13756 }
13757 arg4 = static_cast< byte >(val4);
13758 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13759 if (!SWIG_IsOK(ecode5)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13761 }
13762 arg5 = static_cast< byte >(val5);
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 resultobj = SWIG_Py_Void();
13770 return resultobj;
13771 fail:
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxImage *arg1 = (wxImage *) 0 ;
13779 int arg2 ;
13780 int arg3 ;
13781 byte result;
13782 void *argp1 = 0 ;
13783 int res1 = 0 ;
13784 int val2 ;
13785 int ecode2 = 0 ;
13786 int val3 ;
13787 int ecode3 = 0 ;
13788 PyObject * obj0 = 0 ;
13789 PyObject * obj1 = 0 ;
13790 PyObject * obj2 = 0 ;
13791 char * kwnames[] = {
13792 (char *) "self",(char *) "x",(char *) "y", NULL
13793 };
13794
13795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13797 if (!SWIG_IsOK(res1)) {
13798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13799 }
13800 arg1 = reinterpret_cast< wxImage * >(argp1);
13801 ecode2 = SWIG_AsVal_int(obj1, &val2);
13802 if (!SWIG_IsOK(ecode2)) {
13803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13804 }
13805 arg2 = static_cast< int >(val2);
13806 ecode3 = SWIG_AsVal_int(obj2, &val3);
13807 if (!SWIG_IsOK(ecode3)) {
13808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13809 }
13810 arg3 = static_cast< int >(val3);
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (byte)(arg1)->GetRed(arg2,arg3);
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj = 0;
13826 wxImage *arg1 = (wxImage *) 0 ;
13827 int arg2 ;
13828 int arg3 ;
13829 byte result;
13830 void *argp1 = 0 ;
13831 int res1 = 0 ;
13832 int val2 ;
13833 int ecode2 = 0 ;
13834 int val3 ;
13835 int ecode3 = 0 ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "self",(char *) "x",(char *) "y", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13847 }
13848 arg1 = reinterpret_cast< wxImage * >(argp1);
13849 ecode2 = SWIG_AsVal_int(obj1, &val2);
13850 if (!SWIG_IsOK(ecode2)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13852 }
13853 arg2 = static_cast< int >(val2);
13854 ecode3 = SWIG_AsVal_int(obj2, &val3);
13855 if (!SWIG_IsOK(ecode3)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13857 }
13858 arg3 = static_cast< int >(val3);
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 result = (byte)(arg1)->GetGreen(arg2,arg3);
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13866 return resultobj;
13867 fail:
13868 return NULL;
13869 }
13870
13871
13872 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13873 PyObject *resultobj = 0;
13874 wxImage *arg1 = (wxImage *) 0 ;
13875 int arg2 ;
13876 int arg3 ;
13877 byte result;
13878 void *argp1 = 0 ;
13879 int res1 = 0 ;
13880 int val2 ;
13881 int ecode2 = 0 ;
13882 int val3 ;
13883 int ecode3 = 0 ;
13884 PyObject * obj0 = 0 ;
13885 PyObject * obj1 = 0 ;
13886 PyObject * obj2 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "self",(char *) "x",(char *) "y", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13895 }
13896 arg1 = reinterpret_cast< wxImage * >(argp1);
13897 ecode2 = SWIG_AsVal_int(obj1, &val2);
13898 if (!SWIG_IsOK(ecode2)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13900 }
13901 arg2 = static_cast< int >(val2);
13902 ecode3 = SWIG_AsVal_int(obj2, &val3);
13903 if (!SWIG_IsOK(ecode3)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13905 }
13906 arg3 = static_cast< int >(val3);
13907 {
13908 PyThreadState* __tstate = wxPyBeginAllowThreads();
13909 result = (byte)(arg1)->GetBlue(arg2,arg3);
13910 wxPyEndAllowThreads(__tstate);
13911 if (PyErr_Occurred()) SWIG_fail;
13912 }
13913 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13914 return resultobj;
13915 fail:
13916 return NULL;
13917 }
13918
13919
13920 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj = 0;
13922 wxImage *arg1 = (wxImage *) 0 ;
13923 int arg2 ;
13924 int arg3 ;
13925 byte arg4 ;
13926 void *argp1 = 0 ;
13927 int res1 = 0 ;
13928 int val2 ;
13929 int ecode2 = 0 ;
13930 int val3 ;
13931 int ecode3 = 0 ;
13932 unsigned char val4 ;
13933 int ecode4 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 PyObject * obj3 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13944 if (!SWIG_IsOK(res1)) {
13945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13946 }
13947 arg1 = reinterpret_cast< wxImage * >(argp1);
13948 ecode2 = SWIG_AsVal_int(obj1, &val2);
13949 if (!SWIG_IsOK(ecode2)) {
13950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13951 }
13952 arg2 = static_cast< int >(val2);
13953 ecode3 = SWIG_AsVal_int(obj2, &val3);
13954 if (!SWIG_IsOK(ecode3)) {
13955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13956 }
13957 arg3 = static_cast< int >(val3);
13958 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13959 if (!SWIG_IsOK(ecode4)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13961 }
13962 arg4 = static_cast< byte >(val4);
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 (arg1)->SetAlpha(arg2,arg3,arg4);
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 resultobj = SWIG_Py_Void();
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj = 0;
13978 wxImage *arg1 = (wxImage *) 0 ;
13979 int arg2 ;
13980 int arg3 ;
13981 byte result;
13982 void *argp1 = 0 ;
13983 int res1 = 0 ;
13984 int val2 ;
13985 int ecode2 = 0 ;
13986 int val3 ;
13987 int ecode3 = 0 ;
13988 PyObject * obj0 = 0 ;
13989 PyObject * obj1 = 0 ;
13990 PyObject * obj2 = 0 ;
13991 char * kwnames[] = {
13992 (char *) "self",(char *) "x",(char *) "y", NULL
13993 };
13994
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13999 }
14000 arg1 = reinterpret_cast< wxImage * >(argp1);
14001 ecode2 = SWIG_AsVal_int(obj1, &val2);
14002 if (!SWIG_IsOK(ecode2)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14004 }
14005 arg2 = static_cast< int >(val2);
14006 ecode3 = SWIG_AsVal_int(obj2, &val3);
14007 if (!SWIG_IsOK(ecode3)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14009 }
14010 arg3 = static_cast< int >(val3);
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14014 wxPyEndAllowThreads(__tstate);
14015 if (PyErr_Occurred()) SWIG_fail;
14016 }
14017 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14025 PyObject *resultobj = 0;
14026 wxImage *arg1 = (wxImage *) 0 ;
14027 bool result;
14028 void *argp1 = 0 ;
14029 int res1 = 0 ;
14030 PyObject *swig_obj[1] ;
14031
14032 if (!args) SWIG_fail;
14033 swig_obj[0] = args;
14034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14035 if (!SWIG_IsOK(res1)) {
14036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14037 }
14038 arg1 = reinterpret_cast< wxImage * >(argp1);
14039 {
14040 PyThreadState* __tstate = wxPyBeginAllowThreads();
14041 result = (bool)(arg1)->HasAlpha();
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 {
14046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14047 }
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14055 PyObject *resultobj = 0;
14056 wxImage *arg1 = (wxImage *) 0 ;
14057 void *argp1 = 0 ;
14058 int res1 = 0 ;
14059 PyObject *swig_obj[1] ;
14060
14061 if (!args) SWIG_fail;
14062 swig_obj[0] = args;
14063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14064 if (!SWIG_IsOK(res1)) {
14065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14066 }
14067 arg1 = reinterpret_cast< wxImage * >(argp1);
14068 {
14069 PyThreadState* __tstate = wxPyBeginAllowThreads();
14070 (arg1)->InitAlpha();
14071 wxPyEndAllowThreads(__tstate);
14072 if (PyErr_Occurred()) SWIG_fail;
14073 }
14074 resultobj = SWIG_Py_Void();
14075 return resultobj;
14076 fail:
14077 return NULL;
14078 }
14079
14080
14081 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj = 0;
14083 wxImage *arg1 = (wxImage *) 0 ;
14084 int arg2 ;
14085 int arg3 ;
14086 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14087 bool result;
14088 void *argp1 = 0 ;
14089 int res1 = 0 ;
14090 int val2 ;
14091 int ecode2 = 0 ;
14092 int val3 ;
14093 int ecode3 = 0 ;
14094 unsigned char val4 ;
14095 int ecode4 = 0 ;
14096 PyObject * obj0 = 0 ;
14097 PyObject * obj1 = 0 ;
14098 PyObject * obj2 = 0 ;
14099 PyObject * obj3 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14108 }
14109 arg1 = reinterpret_cast< wxImage * >(argp1);
14110 ecode2 = SWIG_AsVal_int(obj1, &val2);
14111 if (!SWIG_IsOK(ecode2)) {
14112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14113 }
14114 arg2 = static_cast< int >(val2);
14115 ecode3 = SWIG_AsVal_int(obj2, &val3);
14116 if (!SWIG_IsOK(ecode3)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14118 }
14119 arg3 = static_cast< int >(val3);
14120 if (obj3) {
14121 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14122 if (!SWIG_IsOK(ecode4)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14124 }
14125 arg4 = static_cast< byte >(val4);
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14135 }
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 byte *arg2 = (byte *) 0 ;
14146 byte *arg3 = (byte *) 0 ;
14147 byte *arg4 = (byte *) 0 ;
14148 byte arg5 = (byte) 0 ;
14149 byte arg6 = (byte) 0 ;
14150 byte arg7 = (byte) 0 ;
14151 bool result;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 byte temp2 ;
14155 int res2 = SWIG_TMPOBJ ;
14156 byte temp3 ;
14157 int res3 = SWIG_TMPOBJ ;
14158 byte temp4 ;
14159 int res4 = SWIG_TMPOBJ ;
14160 unsigned char val5 ;
14161 int ecode5 = 0 ;
14162 unsigned char val6 ;
14163 int ecode6 = 0 ;
14164 unsigned char val7 ;
14165 int ecode7 = 0 ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 PyObject * obj2 = 0 ;
14169 PyObject * obj3 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14172 };
14173
14174 arg2 = &temp2;
14175 arg3 = &temp3;
14176 arg4 = &temp4;
14177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14179 if (!SWIG_IsOK(res1)) {
14180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14181 }
14182 arg1 = reinterpret_cast< wxImage * >(argp1);
14183 if (obj1) {
14184 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14185 if (!SWIG_IsOK(ecode5)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14187 }
14188 arg5 = static_cast< byte >(val5);
14189 }
14190 if (obj2) {
14191 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14192 if (!SWIG_IsOK(ecode6)) {
14193 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14194 }
14195 arg6 = static_cast< byte >(val6);
14196 }
14197 if (obj3) {
14198 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14199 if (!SWIG_IsOK(ecode7)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14201 }
14202 arg7 = static_cast< byte >(val7);
14203 }
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 {
14211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14212 }
14213 if (SWIG_IsTmpObj(res2)) {
14214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14215 } else {
14216 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14218 }
14219 if (SWIG_IsTmpObj(res3)) {
14220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14221 } else {
14222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14224 }
14225 if (SWIG_IsTmpObj(res4)) {
14226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14227 } else {
14228 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14230 }
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj = 0;
14239 wxImage *arg1 = (wxImage *) 0 ;
14240 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14241 bool result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 unsigned char val2 ;
14245 int ecode2 = 0 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 char * kwnames[] = {
14249 (char *) "self",(char *) "threshold", NULL
14250 };
14251
14252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14254 if (!SWIG_IsOK(res1)) {
14255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14256 }
14257 arg1 = reinterpret_cast< wxImage * >(argp1);
14258 if (obj1) {
14259 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14260 if (!SWIG_IsOK(ecode2)) {
14261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14262 }
14263 arg2 = static_cast< byte >(val2);
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14273 }
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj = 0;
14282 wxImage *arg1 = (wxImage *) 0 ;
14283 byte arg2 ;
14284 byte arg3 ;
14285 byte arg4 ;
14286 bool result;
14287 void *argp1 = 0 ;
14288 int res1 = 0 ;
14289 unsigned char val2 ;
14290 int ecode2 = 0 ;
14291 unsigned char val3 ;
14292 int ecode3 = 0 ;
14293 unsigned char val4 ;
14294 int ecode4 = 0 ;
14295 PyObject * obj0 = 0 ;
14296 PyObject * obj1 = 0 ;
14297 PyObject * obj2 = 0 ;
14298 PyObject * obj3 = 0 ;
14299 char * kwnames[] = {
14300 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14301 };
14302
14303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14305 if (!SWIG_IsOK(res1)) {
14306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14307 }
14308 arg1 = reinterpret_cast< wxImage * >(argp1);
14309 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14310 if (!SWIG_IsOK(ecode2)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14312 }
14313 arg2 = static_cast< byte >(val2);
14314 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14315 if (!SWIG_IsOK(ecode3)) {
14316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14317 }
14318 arg3 = static_cast< byte >(val3);
14319 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14320 if (!SWIG_IsOK(ecode4)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14322 }
14323 arg4 = static_cast< byte >(val4);
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 {
14331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14332 }
14333 return resultobj;
14334 fail:
14335 return NULL;
14336 }
14337
14338
14339 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj = 0;
14341 wxImage *arg1 = (wxImage *) 0 ;
14342 wxImage *arg2 = 0 ;
14343 byte arg3 ;
14344 byte arg4 ;
14345 byte arg5 ;
14346 bool result;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 void *argp2 = 0 ;
14350 int res2 = 0 ;
14351 unsigned char val3 ;
14352 int ecode3 = 0 ;
14353 unsigned char val4 ;
14354 int ecode4 = 0 ;
14355 unsigned char val5 ;
14356 int ecode5 = 0 ;
14357 PyObject * obj0 = 0 ;
14358 PyObject * obj1 = 0 ;
14359 PyObject * obj2 = 0 ;
14360 PyObject * obj3 = 0 ;
14361 PyObject * obj4 = 0 ;
14362 char * kwnames[] = {
14363 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14364 };
14365
14366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14368 if (!SWIG_IsOK(res1)) {
14369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14370 }
14371 arg1 = reinterpret_cast< wxImage * >(argp1);
14372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14373 if (!SWIG_IsOK(res2)) {
14374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14375 }
14376 if (!argp2) {
14377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14378 }
14379 arg2 = reinterpret_cast< wxImage * >(argp2);
14380 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14381 if (!SWIG_IsOK(ecode3)) {
14382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14383 }
14384 arg3 = static_cast< byte >(val3);
14385 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14386 if (!SWIG_IsOK(ecode4)) {
14387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14388 }
14389 arg4 = static_cast< byte >(val4);
14390 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14391 if (!SWIG_IsOK(ecode5)) {
14392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14393 }
14394 arg5 = static_cast< byte >(val5);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 {
14402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14403 }
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj = 0;
14412 wxString *arg1 = 0 ;
14413 bool result;
14414 bool temp1 = false ;
14415 PyObject * obj0 = 0 ;
14416 char * kwnames[] = {
14417 (char *) "filename", NULL
14418 };
14419
14420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14421 {
14422 arg1 = wxString_in_helper(obj0);
14423 if (arg1 == NULL) SWIG_fail;
14424 temp1 = true;
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14434 }
14435 {
14436 if (temp1)
14437 delete arg1;
14438 }
14439 return resultobj;
14440 fail:
14441 {
14442 if (temp1)
14443 delete arg1;
14444 }
14445 return NULL;
14446 }
14447
14448
14449 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj = 0;
14451 wxString *arg1 = 0 ;
14452 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14453 int result;
14454 bool temp1 = false ;
14455 long val2 ;
14456 int ecode2 = 0 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 char * kwnames[] = {
14460 (char *) "filename",(char *) "type", NULL
14461 };
14462
14463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14464 {
14465 arg1 = wxString_in_helper(obj0);
14466 if (arg1 == NULL) SWIG_fail;
14467 temp1 = true;
14468 }
14469 if (obj1) {
14470 ecode2 = SWIG_AsVal_long(obj1, &val2);
14471 if (!SWIG_IsOK(ecode2)) {
14472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14473 }
14474 arg2 = static_cast< long >(val2);
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = SWIG_From_int(static_cast< int >(result));
14483 {
14484 if (temp1)
14485 delete arg1;
14486 }
14487 return resultobj;
14488 fail:
14489 {
14490 if (temp1)
14491 delete arg1;
14492 }
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxImage *arg1 = (wxImage *) 0 ;
14500 wxString *arg2 = 0 ;
14501 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14502 int arg4 = (int) -1 ;
14503 bool result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 bool temp2 = false ;
14507 long val3 ;
14508 int ecode3 = 0 ;
14509 int val4 ;
14510 int ecode4 = 0 ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 PyObject * obj2 = 0 ;
14514 PyObject * obj3 = 0 ;
14515 char * kwnames[] = {
14516 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14517 };
14518
14519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14523 }
14524 arg1 = reinterpret_cast< wxImage * >(argp1);
14525 {
14526 arg2 = wxString_in_helper(obj1);
14527 if (arg2 == NULL) SWIG_fail;
14528 temp2 = true;
14529 }
14530 if (obj2) {
14531 ecode3 = SWIG_AsVal_long(obj2, &val3);
14532 if (!SWIG_IsOK(ecode3)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14534 }
14535 arg3 = static_cast< long >(val3);
14536 }
14537 if (obj3) {
14538 ecode4 = SWIG_AsVal_int(obj3, &val4);
14539 if (!SWIG_IsOK(ecode4)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14541 }
14542 arg4 = static_cast< int >(val4);
14543 }
14544 {
14545 PyThreadState* __tstate = wxPyBeginAllowThreads();
14546 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 {
14551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14552 }
14553 {
14554 if (temp2)
14555 delete arg2;
14556 }
14557 return resultobj;
14558 fail:
14559 {
14560 if (temp2)
14561 delete arg2;
14562 }
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj = 0;
14569 wxImage *arg1 = (wxImage *) 0 ;
14570 wxString *arg2 = 0 ;
14571 wxString *arg3 = 0 ;
14572 int arg4 = (int) -1 ;
14573 bool result;
14574 void *argp1 = 0 ;
14575 int res1 = 0 ;
14576 bool temp2 = false ;
14577 bool temp3 = false ;
14578 int val4 ;
14579 int ecode4 = 0 ;
14580 PyObject * obj0 = 0 ;
14581 PyObject * obj1 = 0 ;
14582 PyObject * obj2 = 0 ;
14583 PyObject * obj3 = 0 ;
14584 char * kwnames[] = {
14585 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14586 };
14587
14588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14590 if (!SWIG_IsOK(res1)) {
14591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14592 }
14593 arg1 = reinterpret_cast< wxImage * >(argp1);
14594 {
14595 arg2 = wxString_in_helper(obj1);
14596 if (arg2 == NULL) SWIG_fail;
14597 temp2 = true;
14598 }
14599 {
14600 arg3 = wxString_in_helper(obj2);
14601 if (arg3 == NULL) SWIG_fail;
14602 temp3 = true;
14603 }
14604 if (obj3) {
14605 ecode4 = SWIG_AsVal_int(obj3, &val4);
14606 if (!SWIG_IsOK(ecode4)) {
14607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14608 }
14609 arg4 = static_cast< int >(val4);
14610 }
14611 {
14612 PyThreadState* __tstate = wxPyBeginAllowThreads();
14613 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 {
14618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14619 }
14620 {
14621 if (temp2)
14622 delete arg2;
14623 }
14624 {
14625 if (temp3)
14626 delete arg3;
14627 }
14628 return resultobj;
14629 fail:
14630 {
14631 if (temp2)
14632 delete arg2;
14633 }
14634 {
14635 if (temp3)
14636 delete arg3;
14637 }
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj = 0;
14644 wxImage *arg1 = (wxImage *) 0 ;
14645 wxString *arg2 = 0 ;
14646 int arg3 ;
14647 bool result;
14648 void *argp1 = 0 ;
14649 int res1 = 0 ;
14650 bool temp2 = false ;
14651 int val3 ;
14652 int ecode3 = 0 ;
14653 PyObject * obj0 = 0 ;
14654 PyObject * obj1 = 0 ;
14655 PyObject * obj2 = 0 ;
14656 char * kwnames[] = {
14657 (char *) "self",(char *) "name",(char *) "type", NULL
14658 };
14659
14660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14664 }
14665 arg1 = reinterpret_cast< wxImage * >(argp1);
14666 {
14667 arg2 = wxString_in_helper(obj1);
14668 if (arg2 == NULL) SWIG_fail;
14669 temp2 = true;
14670 }
14671 ecode3 = SWIG_AsVal_int(obj2, &val3);
14672 if (!SWIG_IsOK(ecode3)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14674 }
14675 arg3 = static_cast< int >(val3);
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 {
14683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14684 }
14685 {
14686 if (temp2)
14687 delete arg2;
14688 }
14689 return resultobj;
14690 fail:
14691 {
14692 if (temp2)
14693 delete arg2;
14694 }
14695 return NULL;
14696 }
14697
14698
14699 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj = 0;
14701 wxImage *arg1 = (wxImage *) 0 ;
14702 wxString *arg2 = 0 ;
14703 wxString *arg3 = 0 ;
14704 bool result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 bool temp2 = false ;
14708 bool temp3 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14720 }
14721 arg1 = reinterpret_cast< wxImage * >(argp1);
14722 {
14723 arg2 = wxString_in_helper(obj1);
14724 if (arg2 == NULL) SWIG_fail;
14725 temp2 = true;
14726 }
14727 {
14728 arg3 = wxString_in_helper(obj2);
14729 if (arg3 == NULL) SWIG_fail;
14730 temp3 = true;
14731 }
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 {
14739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14740 }
14741 {
14742 if (temp2)
14743 delete arg2;
14744 }
14745 {
14746 if (temp3)
14747 delete arg3;
14748 }
14749 return resultobj;
14750 fail:
14751 {
14752 if (temp2)
14753 delete arg2;
14754 }
14755 {
14756 if (temp3)
14757 delete arg3;
14758 }
14759 return NULL;
14760 }
14761
14762
14763 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14764 PyObject *resultobj = 0;
14765 wxInputStream *arg1 = 0 ;
14766 bool result;
14767 wxPyInputStream *temp1 ;
14768 bool created1 ;
14769 PyObject * obj0 = 0 ;
14770 char * kwnames[] = {
14771 (char *) "stream", NULL
14772 };
14773
14774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14775 {
14776 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14777 arg1 = temp1->m_wxis;
14778 created1 = false;
14779 } else {
14780 PyErr_Clear(); // clear the failure of the wxPyConvert above
14781 arg1 = wxPyCBInputStream_create(obj0, false);
14782 if (arg1 == NULL) {
14783 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14784 SWIG_fail;
14785 }
14786 created1 = true;
14787 }
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)wxImage::CanRead(*arg1);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (created1) delete arg1;
14800 }
14801 return resultobj;
14802 fail:
14803 {
14804 if (created1) delete arg1;
14805 }
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14811 PyObject *resultobj = 0;
14812 wxImage *arg1 = (wxImage *) 0 ;
14813 wxInputStream *arg2 = 0 ;
14814 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14815 int arg4 = (int) -1 ;
14816 bool result;
14817 void *argp1 = 0 ;
14818 int res1 = 0 ;
14819 wxPyInputStream *temp2 ;
14820 bool created2 ;
14821 long val3 ;
14822 int ecode3 = 0 ;
14823 int val4 ;
14824 int ecode4 = 0 ;
14825 PyObject * obj0 = 0 ;
14826 PyObject * obj1 = 0 ;
14827 PyObject * obj2 = 0 ;
14828 PyObject * obj3 = 0 ;
14829 char * kwnames[] = {
14830 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14831 };
14832
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImage * >(argp1);
14839 {
14840 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14841 arg2 = temp2->m_wxis;
14842 created2 = false;
14843 } else {
14844 PyErr_Clear(); // clear the failure of the wxPyConvert above
14845 arg2 = wxPyCBInputStream_create(obj1, false);
14846 if (arg2 == NULL) {
14847 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14848 SWIG_fail;
14849 }
14850 created2 = true;
14851 }
14852 }
14853 if (obj2) {
14854 ecode3 = SWIG_AsVal_long(obj2, &val3);
14855 if (!SWIG_IsOK(ecode3)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14857 }
14858 arg3 = static_cast< long >(val3);
14859 }
14860 if (obj3) {
14861 ecode4 = SWIG_AsVal_int(obj3, &val4);
14862 if (!SWIG_IsOK(ecode4)) {
14863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14864 }
14865 arg4 = static_cast< int >(val4);
14866 }
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 {
14874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14875 }
14876 {
14877 if (created2) delete arg2;
14878 }
14879 return resultobj;
14880 fail:
14881 {
14882 if (created2) delete arg2;
14883 }
14884 return NULL;
14885 }
14886
14887
14888 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj = 0;
14890 wxImage *arg1 = (wxImage *) 0 ;
14891 wxInputStream *arg2 = 0 ;
14892 wxString *arg3 = 0 ;
14893 int arg4 = (int) -1 ;
14894 bool result;
14895 void *argp1 = 0 ;
14896 int res1 = 0 ;
14897 wxPyInputStream *temp2 ;
14898 bool created2 ;
14899 bool temp3 = false ;
14900 int val4 ;
14901 int ecode4 = 0 ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 PyObject * obj2 = 0 ;
14905 PyObject * obj3 = 0 ;
14906 char * kwnames[] = {
14907 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14908 };
14909
14910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14912 if (!SWIG_IsOK(res1)) {
14913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14914 }
14915 arg1 = reinterpret_cast< wxImage * >(argp1);
14916 {
14917 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14918 arg2 = temp2->m_wxis;
14919 created2 = false;
14920 } else {
14921 PyErr_Clear(); // clear the failure of the wxPyConvert above
14922 arg2 = wxPyCBInputStream_create(obj1, false);
14923 if (arg2 == NULL) {
14924 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14925 SWIG_fail;
14926 }
14927 created2 = true;
14928 }
14929 }
14930 {
14931 arg3 = wxString_in_helper(obj2);
14932 if (arg3 == NULL) SWIG_fail;
14933 temp3 = true;
14934 }
14935 if (obj3) {
14936 ecode4 = SWIG_AsVal_int(obj3, &val4);
14937 if (!SWIG_IsOK(ecode4)) {
14938 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14939 }
14940 arg4 = static_cast< int >(val4);
14941 }
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 {
14949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14950 }
14951 {
14952 if (created2) delete arg2;
14953 }
14954 {
14955 if (temp3)
14956 delete arg3;
14957 }
14958 return resultobj;
14959 fail:
14960 {
14961 if (created2) delete arg2;
14962 }
14963 {
14964 if (temp3)
14965 delete arg3;
14966 }
14967 return NULL;
14968 }
14969
14970
14971 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14972 PyObject *resultobj = 0;
14973 wxImage *arg1 = (wxImage *) 0 ;
14974 bool result;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 PyObject *swig_obj[1] ;
14978
14979 if (!args) SWIG_fail;
14980 swig_obj[0] = args;
14981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14984 }
14985 arg1 = reinterpret_cast< wxImage * >(argp1);
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (bool)(arg1)->Ok();
14989 wxPyEndAllowThreads(__tstate);
14990 if (PyErr_Occurred()) SWIG_fail;
14991 }
14992 {
14993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14994 }
14995 return resultobj;
14996 fail:
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 int result;
15005 void *argp1 = 0 ;
15006 int res1 = 0 ;
15007 PyObject *swig_obj[1] ;
15008
15009 if (!args) SWIG_fail;
15010 swig_obj[0] = args;
15011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15014 }
15015 arg1 = reinterpret_cast< wxImage * >(argp1);
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 result = (int)(arg1)->GetWidth();
15019 wxPyEndAllowThreads(__tstate);
15020 if (PyErr_Occurred()) SWIG_fail;
15021 }
15022 resultobj = SWIG_From_int(static_cast< int >(result));
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 PyObject *resultobj = 0;
15031 wxImage *arg1 = (wxImage *) 0 ;
15032 int result;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 PyObject *swig_obj[1] ;
15036
15037 if (!args) SWIG_fail;
15038 swig_obj[0] = args;
15039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15042 }
15043 arg1 = reinterpret_cast< wxImage * >(argp1);
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (int)(arg1)->GetHeight();
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 resultobj = SWIG_From_int(static_cast< int >(result));
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15058 PyObject *resultobj = 0;
15059 wxImage *arg1 = (wxImage *) 0 ;
15060 wxSize result;
15061 void *argp1 = 0 ;
15062 int res1 = 0 ;
15063 PyObject *swig_obj[1] ;
15064
15065 if (!args) SWIG_fail;
15066 swig_obj[0] = args;
15067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15068 if (!SWIG_IsOK(res1)) {
15069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15070 }
15071 arg1 = reinterpret_cast< wxImage * >(argp1);
15072 {
15073 PyThreadState* __tstate = wxPyBeginAllowThreads();
15074 result = wxImage_GetSize(arg1);
15075 wxPyEndAllowThreads(__tstate);
15076 if (PyErr_Occurred()) SWIG_fail;
15077 }
15078 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15079 return resultobj;
15080 fail:
15081 return NULL;
15082 }
15083
15084
15085 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj = 0;
15087 wxImage *arg1 = (wxImage *) 0 ;
15088 wxRect *arg2 = 0 ;
15089 SwigValueWrapper<wxImage > result;
15090 void *argp1 = 0 ;
15091 int res1 = 0 ;
15092 wxRect temp2 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char * kwnames[] = {
15096 (char *) "self",(char *) "rect", NULL
15097 };
15098
15099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15101 if (!SWIG_IsOK(res1)) {
15102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage * >(argp1);
15105 {
15106 arg2 = &temp2;
15107 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15108 }
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj = 0;
15124 wxImage *arg1 = (wxImage *) 0 ;
15125 wxSize *arg2 = 0 ;
15126 wxPoint *arg3 = 0 ;
15127 int arg4 = (int) -1 ;
15128 int arg5 = (int) -1 ;
15129 int arg6 = (int) -1 ;
15130 SwigValueWrapper<wxImage > result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 wxSize temp2 ;
15134 wxPoint temp3 ;
15135 int val4 ;
15136 int ecode4 = 0 ;
15137 int val5 ;
15138 int ecode5 = 0 ;
15139 int val6 ;
15140 int ecode6 = 0 ;
15141 PyObject * obj0 = 0 ;
15142 PyObject * obj1 = 0 ;
15143 PyObject * obj2 = 0 ;
15144 PyObject * obj3 = 0 ;
15145 PyObject * obj4 = 0 ;
15146 PyObject * obj5 = 0 ;
15147 char * kwnames[] = {
15148 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15149 };
15150
15151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage * >(argp1);
15157 {
15158 arg2 = &temp2;
15159 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15160 }
15161 {
15162 arg3 = &temp3;
15163 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15164 }
15165 if (obj3) {
15166 ecode4 = SWIG_AsVal_int(obj3, &val4);
15167 if (!SWIG_IsOK(ecode4)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15169 }
15170 arg4 = static_cast< int >(val4);
15171 }
15172 if (obj4) {
15173 ecode5 = SWIG_AsVal_int(obj4, &val5);
15174 if (!SWIG_IsOK(ecode5)) {
15175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15176 }
15177 arg5 = static_cast< int >(val5);
15178 }
15179 if (obj5) {
15180 ecode6 = SWIG_AsVal_int(obj5, &val6);
15181 if (!SWIG_IsOK(ecode6)) {
15182 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15183 }
15184 arg6 = static_cast< int >(val6);
15185 }
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15200 PyObject *resultobj = 0;
15201 wxImage *arg1 = (wxImage *) 0 ;
15202 SwigValueWrapper<wxImage > result;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 PyObject *swig_obj[1] ;
15206
15207 if (!args) SWIG_fail;
15208 swig_obj[0] = args;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15212 }
15213 arg1 = reinterpret_cast< wxImage * >(argp1);
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 result = (arg1)->Copy();
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj = 0;
15229 wxImage *arg1 = (wxImage *) 0 ;
15230 wxImage *arg2 = 0 ;
15231 int arg3 ;
15232 int arg4 ;
15233 void *argp1 = 0 ;
15234 int res1 = 0 ;
15235 void *argp2 = 0 ;
15236 int res2 = 0 ;
15237 int val3 ;
15238 int ecode3 = 0 ;
15239 int val4 ;
15240 int ecode4 = 0 ;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 PyObject * obj2 = 0 ;
15244 PyObject * obj3 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15256 if (!SWIG_IsOK(res2)) {
15257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15258 }
15259 if (!argp2) {
15260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15261 }
15262 arg2 = reinterpret_cast< wxImage * >(argp2);
15263 ecode3 = SWIG_AsVal_int(obj2, &val3);
15264 if (!SWIG_IsOK(ecode3)) {
15265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15266 }
15267 arg3 = static_cast< int >(val3);
15268 ecode4 = SWIG_AsVal_int(obj3, &val4);
15269 if (!SWIG_IsOK(ecode4)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15271 }
15272 arg4 = static_cast< int >(val4);
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 resultobj = SWIG_Py_Void();
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15287 PyObject *resultobj = 0;
15288 wxImage *arg1 = (wxImage *) 0 ;
15289 PyObject *result = 0 ;
15290 void *argp1 = 0 ;
15291 int res1 = 0 ;
15292 PyObject *swig_obj[1] ;
15293
15294 if (!args) SWIG_fail;
15295 swig_obj[0] = args;
15296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15299 }
15300 arg1 = reinterpret_cast< wxImage * >(argp1);
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 result = (PyObject *)wxImage_GetData(arg1);
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = result;
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj = 0;
15316 wxImage *arg1 = (wxImage *) 0 ;
15317 buffer arg2 ;
15318 int arg3 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 PyObject * obj0 = 0 ;
15322 PyObject * obj1 = 0 ;
15323 char * kwnames[] = {
15324 (char *) "self",(char *) "data", NULL
15325 };
15326
15327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15331 }
15332 arg1 = reinterpret_cast< wxImage * >(argp1);
15333 {
15334 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 wxImage_SetData(arg1,arg2,arg3);
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 resultobj = SWIG_Py_Void();
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15350 PyObject *resultobj = 0;
15351 wxImage *arg1 = (wxImage *) 0 ;
15352 PyObject *result = 0 ;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 PyObject *swig_obj[1] ;
15356
15357 if (!args) SWIG_fail;
15358 swig_obj[0] = args;
15359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15360 if (!SWIG_IsOK(res1)) {
15361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15362 }
15363 arg1 = reinterpret_cast< wxImage * >(argp1);
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 resultobj = result;
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj = 0;
15379 wxImage *arg1 = (wxImage *) 0 ;
15380 buffer arg2 ;
15381 int arg3 ;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject * obj0 = 0 ;
15385 PyObject * obj1 = 0 ;
15386 char * kwnames[] = {
15387 (char *) "self",(char *) "data", NULL
15388 };
15389
15390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15394 }
15395 arg1 = reinterpret_cast< wxImage * >(argp1);
15396 {
15397 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 wxImage_SetDataBuffer(arg1,arg2,arg3);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_Py_Void();
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxImage *arg1 = (wxImage *) 0 ;
15415 PyObject *result = 0 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15425 }
15426 arg1 = reinterpret_cast< wxImage * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (PyObject *)wxImage_GetAlphaData(arg1);
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = result;
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj = 0;
15442 wxImage *arg1 = (wxImage *) 0 ;
15443 buffer arg2 ;
15444 int arg3 ;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 PyObject * obj0 = 0 ;
15448 PyObject * obj1 = 0 ;
15449 char * kwnames[] = {
15450 (char *) "self",(char *) "alpha", NULL
15451 };
15452
15453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15455 if (!SWIG_IsOK(res1)) {
15456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15457 }
15458 arg1 = reinterpret_cast< wxImage * >(argp1);
15459 {
15460 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15461 }
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 wxImage_SetAlphaData(arg1,arg2,arg3);
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = SWIG_Py_Void();
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *resultobj = 0;
15477 wxImage *arg1 = (wxImage *) 0 ;
15478 PyObject *result = 0 ;
15479 void *argp1 = 0 ;
15480 int res1 = 0 ;
15481 PyObject *swig_obj[1] ;
15482
15483 if (!args) SWIG_fail;
15484 swig_obj[0] = args;
15485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15486 if (!SWIG_IsOK(res1)) {
15487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15488 }
15489 arg1 = reinterpret_cast< wxImage * >(argp1);
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15493 wxPyEndAllowThreads(__tstate);
15494 if (PyErr_Occurred()) SWIG_fail;
15495 }
15496 resultobj = result;
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = 0;
15505 wxImage *arg1 = (wxImage *) 0 ;
15506 buffer arg2 ;
15507 int arg3 ;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "alpha", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage * >(argp1);
15522 {
15523 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15524 }
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 resultobj = SWIG_Py_Void();
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj = 0;
15540 wxImage *arg1 = (wxImage *) 0 ;
15541 byte arg2 ;
15542 byte arg3 ;
15543 byte arg4 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 unsigned char val2 ;
15547 int ecode2 = 0 ;
15548 unsigned char val3 ;
15549 int ecode3 = 0 ;
15550 unsigned char val4 ;
15551 int ecode4 = 0 ;
15552 PyObject * obj0 = 0 ;
15553 PyObject * obj1 = 0 ;
15554 PyObject * obj2 = 0 ;
15555 PyObject * obj3 = 0 ;
15556 char * kwnames[] = {
15557 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15558 };
15559
15560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15562 if (!SWIG_IsOK(res1)) {
15563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15564 }
15565 arg1 = reinterpret_cast< wxImage * >(argp1);
15566 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15567 if (!SWIG_IsOK(ecode2)) {
15568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15569 }
15570 arg2 = static_cast< byte >(val2);
15571 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15572 if (!SWIG_IsOK(ecode3)) {
15573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15574 }
15575 arg3 = static_cast< byte >(val3);
15576 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15577 if (!SWIG_IsOK(ecode4)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15579 }
15580 arg4 = static_cast< byte >(val4);
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 (arg1)->SetMaskColour(arg2,arg3,arg4);
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_Py_Void();
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15595 PyObject *resultobj = 0;
15596 wxImage *arg1 = (wxImage *) 0 ;
15597 byte *arg2 = (byte *) 0 ;
15598 byte *arg3 = (byte *) 0 ;
15599 byte *arg4 = (byte *) 0 ;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 byte temp2 ;
15603 int res2 = SWIG_TMPOBJ ;
15604 byte temp3 ;
15605 int res3 = SWIG_TMPOBJ ;
15606 byte temp4 ;
15607 int res4 = SWIG_TMPOBJ ;
15608 PyObject *swig_obj[1] ;
15609
15610 arg2 = &temp2;
15611 arg3 = &temp3;
15612 arg4 = &temp4;
15613 if (!args) SWIG_fail;
15614 swig_obj[0] = args;
15615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_Py_Void();
15627 if (SWIG_IsTmpObj(res2)) {
15628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15629 } else {
15630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15632 }
15633 if (SWIG_IsTmpObj(res3)) {
15634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15635 } else {
15636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15638 }
15639 if (SWIG_IsTmpObj(res4)) {
15640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15641 } else {
15642 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15644 }
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 byte result;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15664 }
15665 arg1 = reinterpret_cast< wxImage * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (byte)(arg1)->GetMaskRed();
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 byte result;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 PyObject *swig_obj[1] ;
15686
15687 if (!args) SWIG_fail;
15688 swig_obj[0] = args;
15689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15690 if (!SWIG_IsOK(res1)) {
15691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15692 }
15693 arg1 = reinterpret_cast< wxImage * >(argp1);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 result = (byte)(arg1)->GetMaskGreen();
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 byte result;
15711 void *argp1 = 0 ;
15712 int res1 = 0 ;
15713 PyObject *swig_obj[1] ;
15714
15715 if (!args) SWIG_fail;
15716 swig_obj[0] = args;
15717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15718 if (!SWIG_IsOK(res1)) {
15719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15720 }
15721 arg1 = reinterpret_cast< wxImage * >(argp1);
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (byte)(arg1)->GetMaskBlue();
15725 wxPyEndAllowThreads(__tstate);
15726 if (PyErr_Occurred()) SWIG_fail;
15727 }
15728 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15729 return resultobj;
15730 fail:
15731 return NULL;
15732 }
15733
15734
15735 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15736 PyObject *resultobj = 0;
15737 wxImage *arg1 = (wxImage *) 0 ;
15738 bool arg2 = (bool) true ;
15739 void *argp1 = 0 ;
15740 int res1 = 0 ;
15741 bool val2 ;
15742 int ecode2 = 0 ;
15743 PyObject * obj0 = 0 ;
15744 PyObject * obj1 = 0 ;
15745 char * kwnames[] = {
15746 (char *) "self",(char *) "mask", NULL
15747 };
15748
15749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15751 if (!SWIG_IsOK(res1)) {
15752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15753 }
15754 arg1 = reinterpret_cast< wxImage * >(argp1);
15755 if (obj1) {
15756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15757 if (!SWIG_IsOK(ecode2)) {
15758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15759 }
15760 arg2 = static_cast< bool >(val2);
15761 }
15762 {
15763 PyThreadState* __tstate = wxPyBeginAllowThreads();
15764 (arg1)->SetMask(arg2);
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 resultobj = SWIG_Py_Void();
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15776 PyObject *resultobj = 0;
15777 wxImage *arg1 = (wxImage *) 0 ;
15778 bool result;
15779 void *argp1 = 0 ;
15780 int res1 = 0 ;
15781 PyObject *swig_obj[1] ;
15782
15783 if (!args) SWIG_fail;
15784 swig_obj[0] = args;
15785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15788 }
15789 arg1 = reinterpret_cast< wxImage * >(argp1);
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 result = (bool)(arg1)->HasMask();
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 double arg2 ;
15809 wxPoint *arg3 = 0 ;
15810 bool arg4 = (bool) true ;
15811 wxPoint *arg5 = (wxPoint *) NULL ;
15812 SwigValueWrapper<wxImage > result;
15813 void *argp1 = 0 ;
15814 int res1 = 0 ;
15815 double val2 ;
15816 int ecode2 = 0 ;
15817 wxPoint temp3 ;
15818 bool val4 ;
15819 int ecode4 = 0 ;
15820 void *argp5 = 0 ;
15821 int res5 = 0 ;
15822 PyObject * obj0 = 0 ;
15823 PyObject * obj1 = 0 ;
15824 PyObject * obj2 = 0 ;
15825 PyObject * obj3 = 0 ;
15826 PyObject * obj4 = 0 ;
15827 char * kwnames[] = {
15828 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15829 };
15830
15831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15835 }
15836 arg1 = reinterpret_cast< wxImage * >(argp1);
15837 ecode2 = SWIG_AsVal_double(obj1, &val2);
15838 if (!SWIG_IsOK(ecode2)) {
15839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15840 }
15841 arg2 = static_cast< double >(val2);
15842 {
15843 arg3 = &temp3;
15844 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15845 }
15846 if (obj3) {
15847 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15848 if (!SWIG_IsOK(ecode4)) {
15849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15850 }
15851 arg4 = static_cast< bool >(val4);
15852 }
15853 if (obj4) {
15854 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15855 if (!SWIG_IsOK(res5)) {
15856 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15857 }
15858 arg5 = reinterpret_cast< wxPoint * >(argp5);
15859 }
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15867 return resultobj;
15868 fail:
15869 return NULL;
15870 }
15871
15872
15873 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15874 PyObject *resultobj = 0;
15875 wxImage *arg1 = (wxImage *) 0 ;
15876 bool arg2 = (bool) true ;
15877 SwigValueWrapper<wxImage > result;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 bool val2 ;
15881 int ecode2 = 0 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char * kwnames[] = {
15885 (char *) "self",(char *) "clockwise", NULL
15886 };
15887
15888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15890 if (!SWIG_IsOK(res1)) {
15891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15892 }
15893 arg1 = reinterpret_cast< wxImage * >(argp1);
15894 if (obj1) {
15895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15896 if (!SWIG_IsOK(ecode2)) {
15897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15898 }
15899 arg2 = static_cast< bool >(val2);
15900 }
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (arg1)->Rotate90(arg2);
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15915 PyObject *resultobj = 0;
15916 wxImage *arg1 = (wxImage *) 0 ;
15917 bool arg2 = (bool) true ;
15918 SwigValueWrapper<wxImage > result;
15919 void *argp1 = 0 ;
15920 int res1 = 0 ;
15921 bool val2 ;
15922 int ecode2 = 0 ;
15923 PyObject * obj0 = 0 ;
15924 PyObject * obj1 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "self",(char *) "horizontally", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15933 }
15934 arg1 = reinterpret_cast< wxImage * >(argp1);
15935 if (obj1) {
15936 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15937 if (!SWIG_IsOK(ecode2)) {
15938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15939 }
15940 arg2 = static_cast< bool >(val2);
15941 }
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 result = (arg1)->Mirror(arg2);
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15956 PyObject *resultobj = 0;
15957 wxImage *arg1 = (wxImage *) 0 ;
15958 byte arg2 ;
15959 byte arg3 ;
15960 byte arg4 ;
15961 byte arg5 ;
15962 byte arg6 ;
15963 byte arg7 ;
15964 void *argp1 = 0 ;
15965 int res1 = 0 ;
15966 unsigned char val2 ;
15967 int ecode2 = 0 ;
15968 unsigned char val3 ;
15969 int ecode3 = 0 ;
15970 unsigned char val4 ;
15971 int ecode4 = 0 ;
15972 unsigned char val5 ;
15973 int ecode5 = 0 ;
15974 unsigned char val6 ;
15975 int ecode6 = 0 ;
15976 unsigned char val7 ;
15977 int ecode7 = 0 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 PyObject * obj2 = 0 ;
15981 PyObject * obj3 = 0 ;
15982 PyObject * obj4 = 0 ;
15983 PyObject * obj5 = 0 ;
15984 PyObject * obj6 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15998 }
15999 arg2 = static_cast< byte >(val2);
16000 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16001 if (!SWIG_IsOK(ecode3)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16003 }
16004 arg3 = static_cast< byte >(val3);
16005 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16006 if (!SWIG_IsOK(ecode4)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16008 }
16009 arg4 = static_cast< byte >(val4);
16010 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16011 if (!SWIG_IsOK(ecode5)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16013 }
16014 arg5 = static_cast< byte >(val5);
16015 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16016 if (!SWIG_IsOK(ecode6)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16018 }
16019 arg6 = static_cast< byte >(val6);
16020 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16021 if (!SWIG_IsOK(ecode7)) {
16022 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16023 }
16024 arg7 = static_cast< byte >(val7);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_Py_Void();
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 double arg2 = (double) 0.299 ;
16042 double arg3 = (double) 0.587 ;
16043 double arg4 = (double) 0.114 ;
16044 SwigValueWrapper<wxImage > result;
16045 void *argp1 = 0 ;
16046 int res1 = 0 ;
16047 double val2 ;
16048 int ecode2 = 0 ;
16049 double val3 ;
16050 int ecode3 = 0 ;
16051 double val4 ;
16052 int ecode4 = 0 ;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char * kwnames[] = {
16058 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16059 };
16060
16061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16063 if (!SWIG_IsOK(res1)) {
16064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16065 }
16066 arg1 = reinterpret_cast< wxImage * >(argp1);
16067 if (obj1) {
16068 ecode2 = SWIG_AsVal_double(obj1, &val2);
16069 if (!SWIG_IsOK(ecode2)) {
16070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16071 }
16072 arg2 = static_cast< double >(val2);
16073 }
16074 if (obj2) {
16075 ecode3 = SWIG_AsVal_double(obj2, &val3);
16076 if (!SWIG_IsOK(ecode3)) {
16077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16078 }
16079 arg3 = static_cast< double >(val3);
16080 }
16081 if (obj3) {
16082 ecode4 = SWIG_AsVal_double(obj3, &val4);
16083 if (!SWIG_IsOK(ecode4)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16085 }
16086 arg4 = static_cast< double >(val4);
16087 }
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16102 PyObject *resultobj = 0;
16103 wxImage *arg1 = (wxImage *) 0 ;
16104 byte arg2 ;
16105 byte arg3 ;
16106 byte arg4 ;
16107 SwigValueWrapper<wxImage > result;
16108 void *argp1 = 0 ;
16109 int res1 = 0 ;
16110 unsigned char val2 ;
16111 int ecode2 = 0 ;
16112 unsigned char val3 ;
16113 int ecode3 = 0 ;
16114 unsigned char val4 ;
16115 int ecode4 = 0 ;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 PyObject * obj2 = 0 ;
16119 PyObject * obj3 = 0 ;
16120 char * kwnames[] = {
16121 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16122 };
16123
16124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16126 if (!SWIG_IsOK(res1)) {
16127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16128 }
16129 arg1 = reinterpret_cast< wxImage * >(argp1);
16130 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16131 if (!SWIG_IsOK(ecode2)) {
16132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16133 }
16134 arg2 = static_cast< byte >(val2);
16135 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16136 if (!SWIG_IsOK(ecode3)) {
16137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16138 }
16139 arg3 = static_cast< byte >(val3);
16140 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16141 if (!SWIG_IsOK(ecode4)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16143 }
16144 arg4 = static_cast< byte >(val4);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj = 0;
16160 wxImage *arg1 = (wxImage *) 0 ;
16161 wxString *arg2 = 0 ;
16162 wxString *arg3 = 0 ;
16163 void *argp1 = 0 ;
16164 int res1 = 0 ;
16165 bool temp2 = false ;
16166 bool temp3 = false ;
16167 PyObject * obj0 = 0 ;
16168 PyObject * obj1 = 0 ;
16169 PyObject * obj2 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "name",(char *) "value", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 {
16181 arg2 = wxString_in_helper(obj1);
16182 if (arg2 == NULL) SWIG_fail;
16183 temp2 = true;
16184 }
16185 {
16186 arg3 = wxString_in_helper(obj2);
16187 if (arg3 == NULL) SWIG_fail;
16188 temp3 = true;
16189 }
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16193 wxPyEndAllowThreads(__tstate);
16194 if (PyErr_Occurred()) SWIG_fail;
16195 }
16196 resultobj = SWIG_Py_Void();
16197 {
16198 if (temp2)
16199 delete arg2;
16200 }
16201 {
16202 if (temp3)
16203 delete arg3;
16204 }
16205 return resultobj;
16206 fail:
16207 {
16208 if (temp2)
16209 delete arg2;
16210 }
16211 {
16212 if (temp3)
16213 delete arg3;
16214 }
16215 return NULL;
16216 }
16217
16218
16219 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj = 0;
16221 wxImage *arg1 = (wxImage *) 0 ;
16222 wxString *arg2 = 0 ;
16223 int arg3 ;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 bool temp2 = false ;
16227 int val3 ;
16228 int ecode3 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char * kwnames[] = {
16233 (char *) "self",(char *) "name",(char *) "value", NULL
16234 };
16235
16236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16238 if (!SWIG_IsOK(res1)) {
16239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16240 }
16241 arg1 = reinterpret_cast< wxImage * >(argp1);
16242 {
16243 arg2 = wxString_in_helper(obj1);
16244 if (arg2 == NULL) SWIG_fail;
16245 temp2 = true;
16246 }
16247 ecode3 = SWIG_AsVal_int(obj2, &val3);
16248 if (!SWIG_IsOK(ecode3)) {
16249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16250 }
16251 arg3 = static_cast< int >(val3);
16252 {
16253 PyThreadState* __tstate = wxPyBeginAllowThreads();
16254 (arg1)->SetOption((wxString const &)*arg2,arg3);
16255 wxPyEndAllowThreads(__tstate);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 }
16258 resultobj = SWIG_Py_Void();
16259 {
16260 if (temp2)
16261 delete arg2;
16262 }
16263 return resultobj;
16264 fail:
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = 0;
16275 wxImage *arg1 = (wxImage *) 0 ;
16276 wxString *arg2 = 0 ;
16277 wxString result;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 bool temp2 = false ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *) "name", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16291 }
16292 arg1 = reinterpret_cast< wxImage * >(argp1);
16293 {
16294 arg2 = wxString_in_helper(obj1);
16295 if (arg2 == NULL) SWIG_fail;
16296 temp2 = true;
16297 }
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 #if wxUSE_UNICODE
16306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16307 #else
16308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16309 #endif
16310 }
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 return resultobj;
16316 fail:
16317 {
16318 if (temp2)
16319 delete arg2;
16320 }
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 wxString *arg2 = 0 ;
16329 int result;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 bool temp2 = false ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 char * kwnames[] = {
16336 (char *) "self",(char *) "name", NULL
16337 };
16338
16339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16341 if (!SWIG_IsOK(res1)) {
16342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16343 }
16344 arg1 = reinterpret_cast< wxImage * >(argp1);
16345 {
16346 arg2 = wxString_in_helper(obj1);
16347 if (arg2 == NULL) SWIG_fail;
16348 temp2 = true;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_From_int(static_cast< int >(result));
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return resultobj;
16362 fail:
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxString *arg2 = 0 ;
16375 bool result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 bool temp2 = false ;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char * kwnames[] = {
16382 (char *) "self",(char *) "name", NULL
16383 };
16384
16385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16387 if (!SWIG_IsOK(res1)) {
16388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16389 }
16390 arg1 = reinterpret_cast< wxImage * >(argp1);
16391 {
16392 arg2 = wxString_in_helper(obj1);
16393 if (arg2 == NULL) SWIG_fail;
16394 temp2 = true;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 {
16403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16404 }
16405 {
16406 if (temp2)
16407 delete arg2;
16408 }
16409 return resultobj;
16410 fail:
16411 {
16412 if (temp2)
16413 delete arg2;
16414 }
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImage *arg1 = (wxImage *) 0 ;
16422 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16423 unsigned long result;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 unsigned long val2 ;
16427 int ecode2 = 0 ;
16428 PyObject * obj0 = 0 ;
16429 PyObject * obj1 = 0 ;
16430 char * kwnames[] = {
16431 (char *) "self",(char *) "stopafter", NULL
16432 };
16433
16434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16436 if (!SWIG_IsOK(res1)) {
16437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16438 }
16439 arg1 = reinterpret_cast< wxImage * >(argp1);
16440 if (obj1) {
16441 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16442 if (!SWIG_IsOK(ecode2)) {
16443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16444 }
16445 arg2 = static_cast< unsigned long >(val2);
16446 }
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (unsigned long)(arg1)->CountColours(arg2);
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16454 return resultobj;
16455 fail:
16456 return NULL;
16457 }
16458
16459
16460 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16461 PyObject *resultobj = 0;
16462 wxImage *arg1 = (wxImage *) 0 ;
16463 wxImageHistogram *arg2 = 0 ;
16464 unsigned long result;
16465 void *argp1 = 0 ;
16466 int res1 = 0 ;
16467 void *argp2 = 0 ;
16468 int res2 = 0 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 char * kwnames[] = {
16472 (char *) "self",(char *) "h", NULL
16473 };
16474
16475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16477 if (!SWIG_IsOK(res1)) {
16478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16479 }
16480 arg1 = reinterpret_cast< wxImage * >(argp1);
16481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16482 if (!SWIG_IsOK(res2)) {
16483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16484 }
16485 if (!argp2) {
16486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16487 }
16488 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj = 0;
16504 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16505 void *argp1 = 0 ;
16506 int res1 = 0 ;
16507 PyObject * obj0 = 0 ;
16508 char * kwnames[] = {
16509 (char *) "handler", NULL
16510 };
16511
16512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16514 if (!SWIG_IsOK(res1)) {
16515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16516 }
16517 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 wxImage::AddHandler(arg1);
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 resultobj = SWIG_Py_Void();
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj = 0;
16533 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16534 void *argp1 = 0 ;
16535 int res1 = 0 ;
16536 PyObject * obj0 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "handler", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16543 if (!SWIG_IsOK(res1)) {
16544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16545 }
16546 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 wxImage::InsertHandler(arg1);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 resultobj = SWIG_Py_Void();
16554 return resultobj;
16555 fail:
16556 return NULL;
16557 }
16558
16559
16560 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16561 PyObject *resultobj = 0;
16562 wxString *arg1 = 0 ;
16563 bool result;
16564 bool temp1 = false ;
16565 PyObject * obj0 = 0 ;
16566 char * kwnames[] = {
16567 (char *) "name", NULL
16568 };
16569
16570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16571 {
16572 arg1 = wxString_in_helper(obj0);
16573 if (arg1 == NULL) SWIG_fail;
16574 temp1 = true;
16575 }
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16584 }
16585 {
16586 if (temp1)
16587 delete arg1;
16588 }
16589 return resultobj;
16590 fail:
16591 {
16592 if (temp1)
16593 delete arg1;
16594 }
16595 return NULL;
16596 }
16597
16598
16599 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16600 PyObject *resultobj = 0;
16601 PyObject *result = 0 ;
16602
16603 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 result = (PyObject *)wxImage_GetHandlers();
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = result;
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16618 PyObject *resultobj = 0;
16619 wxString result;
16620
16621 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 result = wxImage::GetImageExtWildcard();
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 #if wxUSE_UNICODE
16630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16631 #else
16632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16633 #endif
16634 }
16635 return resultobj;
16636 fail:
16637 return NULL;
16638 }
16639
16640
16641 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16642 PyObject *resultobj = 0;
16643 wxImage *arg1 = (wxImage *) 0 ;
16644 int arg2 = (int) -1 ;
16645 wxBitmap result;
16646 void *argp1 = 0 ;
16647 int res1 = 0 ;
16648 int val2 ;
16649 int ecode2 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 char * kwnames[] = {
16653 (char *) "self",(char *) "depth", NULL
16654 };
16655
16656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16658 if (!SWIG_IsOK(res1)) {
16659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16660 }
16661 arg1 = reinterpret_cast< wxImage * >(argp1);
16662 if (obj1) {
16663 ecode2 = SWIG_AsVal_int(obj1, &val2);
16664 if (!SWIG_IsOK(ecode2)) {
16665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16666 }
16667 arg2 = static_cast< int >(val2);
16668 }
16669 {
16670 if (!wxPyCheckForApp()) SWIG_fail;
16671 PyThreadState* __tstate = wxPyBeginAllowThreads();
16672 result = wxImage_ConvertToBitmap(arg1,arg2);
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj = 0;
16685 wxImage *arg1 = (wxImage *) 0 ;
16686 byte arg2 ;
16687 byte arg3 ;
16688 byte arg4 ;
16689 wxBitmap result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 unsigned char val2 ;
16693 int ecode2 = 0 ;
16694 unsigned char val3 ;
16695 int ecode3 = 0 ;
16696 unsigned char val4 ;
16697 int ecode4 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 PyObject * obj1 = 0 ;
16700 PyObject * obj2 = 0 ;
16701 PyObject * obj3 = 0 ;
16702 char * kwnames[] = {
16703 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16704 };
16705
16706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16710 }
16711 arg1 = reinterpret_cast< wxImage * >(argp1);
16712 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16713 if (!SWIG_IsOK(ecode2)) {
16714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16715 }
16716 arg2 = static_cast< byte >(val2);
16717 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16718 if (!SWIG_IsOK(ecode3)) {
16719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16720 }
16721 arg3 = static_cast< byte >(val3);
16722 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16723 if (!SWIG_IsOK(ecode4)) {
16724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16725 }
16726 arg4 = static_cast< byte >(val4);
16727 {
16728 if (!wxPyCheckForApp()) SWIG_fail;
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj = 0;
16743 wxImage *arg1 = (wxImage *) 0 ;
16744 double arg2 ;
16745 void *argp1 = 0 ;
16746 int res1 = 0 ;
16747 double val2 ;
16748 int ecode2 = 0 ;
16749 PyObject * obj0 = 0 ;
16750 PyObject * obj1 = 0 ;
16751 char * kwnames[] = {
16752 (char *) "self",(char *) "angle", NULL
16753 };
16754
16755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16759 }
16760 arg1 = reinterpret_cast< wxImage * >(argp1);
16761 ecode2 = SWIG_AsVal_double(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16764 }
16765 arg2 = static_cast< double >(val2);
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->RotateHue(arg2);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = SWIG_Py_Void();
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj = 0;
16781 wxImage_RGBValue arg1 ;
16782 wxImage_HSVValue result;
16783 void *argp1 ;
16784 int res1 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "rgb", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16791 {
16792 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16795 }
16796 if (!argp1) {
16797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16798 } else {
16799 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16800 arg1 = *temp;
16801 if (SWIG_IsNewObj(res1)) delete temp;
16802 }
16803 }
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = wxImage::RGBtoHSV(arg1);
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = 0;
16819 wxImage_HSVValue arg1 ;
16820 wxImage_RGBValue result;
16821 void *argp1 ;
16822 int res1 = 0 ;
16823 PyObject * obj0 = 0 ;
16824 char * kwnames[] = {
16825 (char *) "hsv", NULL
16826 };
16827
16828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16829 {
16830 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16831 if (!SWIG_IsOK(res1)) {
16832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16833 }
16834 if (!argp1) {
16835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16836 } else {
16837 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16838 arg1 = *temp;
16839 if (SWIG_IsNewObj(res1)) delete temp;
16840 }
16841 }
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = wxImage::HSVtoRGB(arg1);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16856 PyObject *obj;
16857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16858 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16859 return SWIG_Py_Void();
16860 }
16861
16862 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16863 return SWIG_Python_InitShadowInstance(args);
16864 }
16865
16866 SWIGINTERN int NullImage_set(PyObject *) {
16867 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16868 return 1;
16869 }
16870
16871
16872 SWIGINTERN PyObject *NullImage_get(void) {
16873 PyObject *pyobj = 0;
16874
16875 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16876 return pyobj;
16877 }
16878
16879
16880 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16881 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16882 return 1;
16883 }
16884
16885
16886 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16887 PyObject *pyobj = 0;
16888
16889 {
16890 #if wxUSE_UNICODE
16891 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16892 #else
16893 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16894 #endif
16895 }
16896 return pyobj;
16897 }
16898
16899
16900 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16901 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16902 return 1;
16903 }
16904
16905
16906 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16907 PyObject *pyobj = 0;
16908
16909 {
16910 #if wxUSE_UNICODE
16911 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16912 #else
16913 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16914 #endif
16915 }
16916 return pyobj;
16917 }
16918
16919
16920 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16921 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16922 return 1;
16923 }
16924
16925
16926 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16927 PyObject *pyobj = 0;
16928
16929 {
16930 #if wxUSE_UNICODE
16931 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16932 #else
16933 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16934 #endif
16935 }
16936 return pyobj;
16937 }
16938
16939
16940 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16941 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16942 return 1;
16943 }
16944
16945
16946 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16947 PyObject *pyobj = 0;
16948
16949 {
16950 #if wxUSE_UNICODE
16951 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16952 #else
16953 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16954 #endif
16955 }
16956 return pyobj;
16957 }
16958
16959
16960 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16961 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16962 return 1;
16963 }
16964
16965
16966 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16967 PyObject *pyobj = 0;
16968
16969 {
16970 #if wxUSE_UNICODE
16971 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16972 #else
16973 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16974 #endif
16975 }
16976 return pyobj;
16977 }
16978
16979
16980 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16981 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16982 return 1;
16983 }
16984
16985
16986 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16987 PyObject *pyobj = 0;
16988
16989 {
16990 #if wxUSE_UNICODE
16991 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16992 #else
16993 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16994 #endif
16995 }
16996 return pyobj;
16997 }
16998
16999
17000 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17001 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17002 return 1;
17003 }
17004
17005
17006 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17007 PyObject *pyobj = 0;
17008
17009 {
17010 #if wxUSE_UNICODE
17011 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17012 #else
17013 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17014 #endif
17015 }
17016 return pyobj;
17017 }
17018
17019
17020 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17021 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17022 return 1;
17023 }
17024
17025
17026 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17027 PyObject *pyobj = 0;
17028
17029 {
17030 #if wxUSE_UNICODE
17031 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17032 #else
17033 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17034 #endif
17035 }
17036 return pyobj;
17037 }
17038
17039
17040 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17041 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17042 return 1;
17043 }
17044
17045
17046 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17047 PyObject *pyobj = 0;
17048
17049 {
17050 #if wxUSE_UNICODE
17051 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17052 #else
17053 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17054 #endif
17055 }
17056 return pyobj;
17057 }
17058
17059
17060 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17061 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17062 return 1;
17063 }
17064
17065
17066 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17067 PyObject *pyobj = 0;
17068
17069 {
17070 #if wxUSE_UNICODE
17071 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17072 #else
17073 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17074 #endif
17075 }
17076 return pyobj;
17077 }
17078
17079
17080 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17081 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17082 return 1;
17083 }
17084
17085
17086 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17087 PyObject *pyobj = 0;
17088
17089 {
17090 #if wxUSE_UNICODE
17091 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17092 #else
17093 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17094 #endif
17095 }
17096 return pyobj;
17097 }
17098
17099
17100 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17101 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17102 return 1;
17103 }
17104
17105
17106 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17107 PyObject *pyobj = 0;
17108
17109 {
17110 #if wxUSE_UNICODE
17111 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17112 #else
17113 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17114 #endif
17115 }
17116 return pyobj;
17117 }
17118
17119
17120 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17121 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17122 return 1;
17123 }
17124
17125
17126 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17127 PyObject *pyobj = 0;
17128
17129 {
17130 #if wxUSE_UNICODE
17131 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17132 #else
17133 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17134 #endif
17135 }
17136 return pyobj;
17137 }
17138
17139
17140 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17141 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17142 return 1;
17143 }
17144
17145
17146 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17147 PyObject *pyobj = 0;
17148
17149 {
17150 #if wxUSE_UNICODE
17151 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17152 #else
17153 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17154 #endif
17155 }
17156 return pyobj;
17157 }
17158
17159
17160 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17161 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17162 return 1;
17163 }
17164
17165
17166 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17167 PyObject *pyobj = 0;
17168
17169 {
17170 #if wxUSE_UNICODE
17171 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17172 #else
17173 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17174 #endif
17175 }
17176 return pyobj;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17181 PyObject *resultobj = 0;
17182 wxBMPHandler *result = 0 ;
17183
17184 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17185 {
17186 PyThreadState* __tstate = wxPyBeginAllowThreads();
17187 result = (wxBMPHandler *)new wxBMPHandler();
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17199 PyObject *obj;
17200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17201 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17202 return SWIG_Py_Void();
17203 }
17204
17205 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17206 return SWIG_Python_InitShadowInstance(args);
17207 }
17208
17209 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17210 PyObject *resultobj = 0;
17211 wxICOHandler *result = 0 ;
17212
17213 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17214 {
17215 PyThreadState* __tstate = wxPyBeginAllowThreads();
17216 result = (wxICOHandler *)new wxICOHandler();
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17228 PyObject *obj;
17229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17230 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17231 return SWIG_Py_Void();
17232 }
17233
17234 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17235 return SWIG_Python_InitShadowInstance(args);
17236 }
17237
17238 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17239 PyObject *resultobj = 0;
17240 wxCURHandler *result = 0 ;
17241
17242 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17243 {
17244 PyThreadState* __tstate = wxPyBeginAllowThreads();
17245 result = (wxCURHandler *)new wxCURHandler();
17246 wxPyEndAllowThreads(__tstate);
17247 if (PyErr_Occurred()) SWIG_fail;
17248 }
17249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17257 PyObject *obj;
17258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17259 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17260 return SWIG_Py_Void();
17261 }
17262
17263 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 return SWIG_Python_InitShadowInstance(args);
17265 }
17266
17267 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17268 PyObject *resultobj = 0;
17269 wxANIHandler *result = 0 ;
17270
17271 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17272 {
17273 PyThreadState* __tstate = wxPyBeginAllowThreads();
17274 result = (wxANIHandler *)new wxANIHandler();
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17286 PyObject *obj;
17287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17288 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17289 return SWIG_Py_Void();
17290 }
17291
17292 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 return SWIG_Python_InitShadowInstance(args);
17294 }
17295
17296 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 PyObject *resultobj = 0;
17298 wxPNGHandler *result = 0 ;
17299
17300 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (wxPNGHandler *)new wxPNGHandler();
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17308 return resultobj;
17309 fail:
17310 return NULL;
17311 }
17312
17313
17314 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17315 PyObject *obj;
17316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17318 return SWIG_Py_Void();
17319 }
17320
17321 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 return SWIG_Python_InitShadowInstance(args);
17323 }
17324
17325 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *resultobj = 0;
17327 wxGIFHandler *result = 0 ;
17328
17329 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (wxGIFHandler *)new wxGIFHandler();
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17337 return resultobj;
17338 fail:
17339 return NULL;
17340 }
17341
17342
17343 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17344 PyObject *obj;
17345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17346 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17347 return SWIG_Py_Void();
17348 }
17349
17350 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 return SWIG_Python_InitShadowInstance(args);
17352 }
17353
17354 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *resultobj = 0;
17356 wxPCXHandler *result = 0 ;
17357
17358 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (wxPCXHandler *)new wxPCXHandler();
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17373 PyObject *obj;
17374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17375 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17376 return SWIG_Py_Void();
17377 }
17378
17379 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 return SWIG_Python_InitShadowInstance(args);
17381 }
17382
17383 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 PyObject *resultobj = 0;
17385 wxJPEGHandler *result = 0 ;
17386
17387 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17388 {
17389 PyThreadState* __tstate = wxPyBeginAllowThreads();
17390 result = (wxJPEGHandler *)new wxJPEGHandler();
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17402 PyObject *obj;
17403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17404 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17405 return SWIG_Py_Void();
17406 }
17407
17408 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17409 return SWIG_Python_InitShadowInstance(args);
17410 }
17411
17412 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 PyObject *resultobj = 0;
17414 wxPNMHandler *result = 0 ;
17415
17416 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 result = (wxPNMHandler *)new wxPNMHandler();
17420 wxPyEndAllowThreads(__tstate);
17421 if (PyErr_Occurred()) SWIG_fail;
17422 }
17423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17424 return resultobj;
17425 fail:
17426 return NULL;
17427 }
17428
17429
17430 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17431 PyObject *obj;
17432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17433 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17434 return SWIG_Py_Void();
17435 }
17436
17437 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 return SWIG_Python_InitShadowInstance(args);
17439 }
17440
17441 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *resultobj = 0;
17443 wxXPMHandler *result = 0 ;
17444
17445 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (wxXPMHandler *)new wxXPMHandler();
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *obj;
17461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17462 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17463 return SWIG_Py_Void();
17464 }
17465
17466 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 return SWIG_Python_InitShadowInstance(args);
17468 }
17469
17470 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *resultobj = 0;
17472 wxTIFFHandler *result = 0 ;
17473
17474 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17475 {
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 result = (wxTIFFHandler *)new wxTIFFHandler();
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17482 return resultobj;
17483 fail:
17484 return NULL;
17485 }
17486
17487
17488 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17489 PyObject *obj;
17490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17491 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17492 return SWIG_Py_Void();
17493 }
17494
17495 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 return SWIG_Python_InitShadowInstance(args);
17497 }
17498
17499 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxImage *arg1 = 0 ;
17502 wxImage *arg2 = 0 ;
17503 int arg3 = (int) 236 ;
17504 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17505 bool result;
17506 void *argp1 = 0 ;
17507 int res1 = 0 ;
17508 void *argp2 = 0 ;
17509 int res2 = 0 ;
17510 int val3 ;
17511 int ecode3 = 0 ;
17512 int val4 ;
17513 int ecode4 = 0 ;
17514 PyObject * obj0 = 0 ;
17515 PyObject * obj1 = 0 ;
17516 PyObject * obj2 = 0 ;
17517 PyObject * obj3 = 0 ;
17518 char * kwnames[] = {
17519 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17520 };
17521
17522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17523 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17524 if (!SWIG_IsOK(res1)) {
17525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17526 }
17527 if (!argp1) {
17528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17529 }
17530 arg1 = reinterpret_cast< wxImage * >(argp1);
17531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17532 if (!SWIG_IsOK(res2)) {
17533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17534 }
17535 if (!argp2) {
17536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17537 }
17538 arg2 = reinterpret_cast< wxImage * >(argp2);
17539 if (obj2) {
17540 ecode3 = SWIG_AsVal_int(obj2, &val3);
17541 if (!SWIG_IsOK(ecode3)) {
17542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17543 }
17544 arg3 = static_cast< int >(val3);
17545 }
17546 if (obj3) {
17547 ecode4 = SWIG_AsVal_int(obj3, &val4);
17548 if (!SWIG_IsOK(ecode4)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17550 }
17551 arg4 = static_cast< int >(val4);
17552 }
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 {
17560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17561 }
17562 return resultobj;
17563 fail:
17564 return NULL;
17565 }
17566
17567
17568 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17569 PyObject *obj;
17570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17571 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17572 return SWIG_Py_Void();
17573 }
17574
17575 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17576 PyObject *resultobj = 0;
17577 wxEvtHandler *result = 0 ;
17578
17579 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17580 {
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 result = (wxEvtHandler *)new wxEvtHandler();
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17594 PyObject *resultobj = 0;
17595 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17596 wxEvtHandler *result = 0 ;
17597 void *argp1 = 0 ;
17598 int res1 = 0 ;
17599 PyObject *swig_obj[1] ;
17600
17601 if (!args) SWIG_fail;
17602 swig_obj[0] = args;
17603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17604 if (!SWIG_IsOK(res1)) {
17605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17606 }
17607 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = wxPyMake_wxObject(result, 0);
17616 }
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *resultobj = 0;
17625 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17626 wxEvtHandler *result = 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 PyObject *swig_obj[1] ;
17630
17631 if (!args) SWIG_fail;
17632 swig_obj[0] = args;
17633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17636 }
17637 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = wxPyMake_wxObject(result, 0);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj = 0;
17655 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17656 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17657 void *argp1 = 0 ;
17658 int res1 = 0 ;
17659 void *argp2 = 0 ;
17660 int res2 = 0 ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 char * kwnames[] = {
17664 (char *) "self",(char *) "handler", NULL
17665 };
17666
17667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17671 }
17672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17674 if (!SWIG_IsOK(res2)) {
17675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17676 }
17677 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 (arg1)->SetNextHandler(arg2);
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = SWIG_Py_Void();
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17692 PyObject *resultobj = 0;
17693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17694 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 void *argp2 = 0 ;
17698 int res2 = 0 ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "self",(char *) "handler", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17707 if (!SWIG_IsOK(res1)) {
17708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17709 }
17710 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17712 if (!SWIG_IsOK(res2)) {
17713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17714 }
17715 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 (arg1)->SetPreviousHandler(arg2);
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 resultobj = SWIG_Py_Void();
17723 return resultobj;
17724 fail:
17725 return NULL;
17726 }
17727
17728
17729 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17730 PyObject *resultobj = 0;
17731 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17732 bool result;
17733 void *argp1 = 0 ;
17734 int res1 = 0 ;
17735 PyObject *swig_obj[1] ;
17736
17737 if (!args) SWIG_fail;
17738 swig_obj[0] = args;
17739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17740 if (!SWIG_IsOK(res1)) {
17741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17742 }
17743 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->GetEvtHandlerEnabled();
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = 0;
17761 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17762 bool arg2 ;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 bool val2 ;
17766 int ecode2 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char * kwnames[] = {
17770 (char *) "self",(char *) "enabled", NULL
17771 };
17772
17773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17775 if (!SWIG_IsOK(res1)) {
17776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17777 }
17778 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17780 if (!SWIG_IsOK(ecode2)) {
17781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17782 }
17783 arg2 = static_cast< bool >(val2);
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 (arg1)->SetEvtHandlerEnabled(arg2);
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 resultobj = SWIG_Py_Void();
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj = 0;
17799 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17800 wxEvent *arg2 = 0 ;
17801 bool result;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 void *argp2 = 0 ;
17805 int res2 = 0 ;
17806 PyObject * obj0 = 0 ;
17807 PyObject * obj1 = 0 ;
17808 char * kwnames[] = {
17809 (char *) "self",(char *) "event", NULL
17810 };
17811
17812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17814 if (!SWIG_IsOK(res1)) {
17815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17816 }
17817 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17819 if (!SWIG_IsOK(res2)) {
17820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17821 }
17822 if (!argp2) {
17823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17824 }
17825 arg2 = reinterpret_cast< wxEvent * >(argp2);
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (bool)(arg1)->ProcessEvent(*arg2);
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 {
17833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17834 }
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17842 PyObject *resultobj = 0;
17843 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17844 wxEvent *arg2 = 0 ;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 void *argp2 = 0 ;
17848 int res2 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 char * kwnames[] = {
17852 (char *) "self",(char *) "event", NULL
17853 };
17854
17855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17859 }
17860 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17862 if (!SWIG_IsOK(res2)) {
17863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17864 }
17865 if (!argp2) {
17866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17867 }
17868 arg2 = reinterpret_cast< wxEvent * >(argp2);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 (arg1)->AddPendingEvent(*arg2);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_Py_Void();
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17885 void *argp1 = 0 ;
17886 int res1 = 0 ;
17887 PyObject *swig_obj[1] ;
17888
17889 if (!args) SWIG_fail;
17890 swig_obj[0] = args;
17891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17894 }
17895 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 (arg1)->ProcessPendingEvents();
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 resultobj = SWIG_Py_Void();
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj = 0;
17911 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17912 int arg2 ;
17913 int arg3 ;
17914 int arg4 ;
17915 PyObject *arg5 = (PyObject *) 0 ;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 int val2 ;
17919 int ecode2 = 0 ;
17920 int val3 ;
17921 int ecode3 = 0 ;
17922 int val4 ;
17923 int ecode4 = 0 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 PyObject * obj2 = 0 ;
17927 PyObject * obj3 = 0 ;
17928 PyObject * obj4 = 0 ;
17929 char * kwnames[] = {
17930 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17931 };
17932
17933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17935 if (!SWIG_IsOK(res1)) {
17936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17937 }
17938 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17939 ecode2 = SWIG_AsVal_int(obj1, &val2);
17940 if (!SWIG_IsOK(ecode2)) {
17941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17942 }
17943 arg2 = static_cast< int >(val2);
17944 ecode3 = SWIG_AsVal_int(obj2, &val3);
17945 if (!SWIG_IsOK(ecode3)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17947 }
17948 arg3 = static_cast< int >(val3);
17949 ecode4 = SWIG_AsVal_int(obj3, &val4);
17950 if (!SWIG_IsOK(ecode4)) {
17951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17952 }
17953 arg4 = static_cast< int >(val4);
17954 arg5 = obj4;
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 resultobj = SWIG_Py_Void();
17962 return resultobj;
17963 fail:
17964 return NULL;
17965 }
17966
17967
17968 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17969 PyObject *resultobj = 0;
17970 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17971 int arg2 ;
17972 int arg3 = (int) -1 ;
17973 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17974 bool result;
17975 void *argp1 = 0 ;
17976 int res1 = 0 ;
17977 int val2 ;
17978 int ecode2 = 0 ;
17979 int val3 ;
17980 int ecode3 = 0 ;
17981 int val4 ;
17982 int ecode4 = 0 ;
17983 PyObject * obj0 = 0 ;
17984 PyObject * obj1 = 0 ;
17985 PyObject * obj2 = 0 ;
17986 PyObject * obj3 = 0 ;
17987 char * kwnames[] = {
17988 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17989 };
17990
17991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17993 if (!SWIG_IsOK(res1)) {
17994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17995 }
17996 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17997 ecode2 = SWIG_AsVal_int(obj1, &val2);
17998 if (!SWIG_IsOK(ecode2)) {
17999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18000 }
18001 arg2 = static_cast< int >(val2);
18002 if (obj2) {
18003 ecode3 = SWIG_AsVal_int(obj2, &val3);
18004 if (!SWIG_IsOK(ecode3)) {
18005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18006 }
18007 arg3 = static_cast< int >(val3);
18008 }
18009 if (obj3) {
18010 ecode4 = SWIG_AsVal_int(obj3, &val4);
18011 if (!SWIG_IsOK(ecode4)) {
18012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18013 }
18014 arg4 = static_cast< wxEventType >(val4);
18015 }
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18034 PyObject *arg2 = (PyObject *) 0 ;
18035 bool arg3 = (bool) true ;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 bool val3 ;
18039 int ecode3 = 0 ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 PyObject * obj2 = 0 ;
18043 char * kwnames[] = {
18044 (char *) "self",(char *) "_self",(char *) "incref", NULL
18045 };
18046
18047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 arg2 = obj1;
18054 if (obj2) {
18055 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18056 if (!SWIG_IsOK(ecode3)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18058 }
18059 arg3 = static_cast< bool >(val3);
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18064 wxPyEndAllowThreads(__tstate);
18065 if (PyErr_Occurred()) SWIG_fail;
18066 }
18067 resultobj = SWIG_Py_Void();
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18075 PyObject *obj;
18076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18077 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18078 return SWIG_Py_Void();
18079 }
18080
18081 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18082 return SWIG_Python_InitShadowInstance(args);
18083 }
18084
18085 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18086 PyObject *resultobj = 0;
18087 wxEventType result;
18088
18089 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (wxEventType)wxNewEventType();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_From_int(static_cast< int >(result));
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxEvent *arg1 = (wxEvent *) 0 ;
18106 void *argp1 = 0 ;
18107 int res1 = 0 ;
18108 PyObject *swig_obj[1] ;
18109
18110 if (!args) SWIG_fail;
18111 swig_obj[0] = args;
18112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18113 if (!SWIG_IsOK(res1)) {
18114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18115 }
18116 arg1 = reinterpret_cast< wxEvent * >(argp1);
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 delete arg1;
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = SWIG_Py_Void();
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj = 0;
18133 wxEvent *arg1 = (wxEvent *) 0 ;
18134 wxEventType arg2 ;
18135 void *argp1 = 0 ;
18136 int res1 = 0 ;
18137 int val2 ;
18138 int ecode2 = 0 ;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 char * kwnames[] = {
18142 (char *) "self",(char *) "typ", NULL
18143 };
18144
18145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18147 if (!SWIG_IsOK(res1)) {
18148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18149 }
18150 arg1 = reinterpret_cast< wxEvent * >(argp1);
18151 ecode2 = SWIG_AsVal_int(obj1, &val2);
18152 if (!SWIG_IsOK(ecode2)) {
18153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18154 }
18155 arg2 = static_cast< wxEventType >(val2);
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 (arg1)->SetEventType(arg2);
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_Py_Void();
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *resultobj = 0;
18171 wxEvent *arg1 = (wxEvent *) 0 ;
18172 wxEventType result;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 PyObject *swig_obj[1] ;
18176
18177 if (!args) SWIG_fail;
18178 swig_obj[0] = args;
18179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18180 if (!SWIG_IsOK(res1)) {
18181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18182 }
18183 arg1 = reinterpret_cast< wxEvent * >(argp1);
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_From_int(static_cast< int >(result));
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *resultobj = 0;
18199 wxEvent *arg1 = (wxEvent *) 0 ;
18200 wxObject *result = 0 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 PyObject *swig_obj[1] ;
18204
18205 if (!args) SWIG_fail;
18206 swig_obj[0] = args;
18207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18210 }
18211 arg1 = reinterpret_cast< wxEvent * >(argp1);
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 {
18219 resultobj = wxPyMake_wxObject(result, (bool)0);
18220 }
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj = 0;
18229 wxEvent *arg1 = (wxEvent *) 0 ;
18230 wxObject *arg2 = (wxObject *) 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 void *argp2 = 0 ;
18234 int res2 = 0 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 char * kwnames[] = {
18238 (char *) "self",(char *) "obj", NULL
18239 };
18240
18241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18245 }
18246 arg1 = reinterpret_cast< wxEvent * >(argp1);
18247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18248 if (!SWIG_IsOK(res2)) {
18249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18250 }
18251 arg2 = reinterpret_cast< wxObject * >(argp2);
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 (arg1)->SetEventObject(arg2);
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 resultobj = SWIG_Py_Void();
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18266 PyObject *resultobj = 0;
18267 wxEvent *arg1 = (wxEvent *) 0 ;
18268 long result;
18269 void *argp1 = 0 ;
18270 int res1 = 0 ;
18271 PyObject *swig_obj[1] ;
18272
18273 if (!args) SWIG_fail;
18274 swig_obj[0] = args;
18275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18278 }
18279 arg1 = reinterpret_cast< wxEvent * >(argp1);
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 resultobj = SWIG_From_long(static_cast< long >(result));
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxEvent *arg1 = (wxEvent *) 0 ;
18296 long arg2 = (long) 0 ;
18297 void *argp1 = 0 ;
18298 int res1 = 0 ;
18299 long val2 ;
18300 int ecode2 = 0 ;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 char * kwnames[] = {
18304 (char *) "self",(char *) "ts", NULL
18305 };
18306
18307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18311 }
18312 arg1 = reinterpret_cast< wxEvent * >(argp1);
18313 if (obj1) {
18314 ecode2 = SWIG_AsVal_long(obj1, &val2);
18315 if (!SWIG_IsOK(ecode2)) {
18316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18317 }
18318 arg2 = static_cast< long >(val2);
18319 }
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 (arg1)->SetTimestamp(arg2);
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 resultobj = SWIG_Py_Void();
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18334 PyObject *resultobj = 0;
18335 wxEvent *arg1 = (wxEvent *) 0 ;
18336 int result;
18337 void *argp1 = 0 ;
18338 int res1 = 0 ;
18339 PyObject *swig_obj[1] ;
18340
18341 if (!args) SWIG_fail;
18342 swig_obj[0] = args;
18343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18346 }
18347 arg1 = reinterpret_cast< wxEvent * >(argp1);
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (int)((wxEvent const *)arg1)->GetId();
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = SWIG_From_int(static_cast< int >(result));
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj = 0;
18363 wxEvent *arg1 = (wxEvent *) 0 ;
18364 int arg2 ;
18365 void *argp1 = 0 ;
18366 int res1 = 0 ;
18367 int val2 ;
18368 int ecode2 = 0 ;
18369 PyObject * obj0 = 0 ;
18370 PyObject * obj1 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "Id", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18379 }
18380 arg1 = reinterpret_cast< wxEvent * >(argp1);
18381 ecode2 = SWIG_AsVal_int(obj1, &val2);
18382 if (!SWIG_IsOK(ecode2)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18384 }
18385 arg2 = static_cast< int >(val2);
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 (arg1)->SetId(arg2);
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 resultobj = SWIG_Py_Void();
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18400 PyObject *resultobj = 0;
18401 wxEvent *arg1 = (wxEvent *) 0 ;
18402 bool result;
18403 void *argp1 = 0 ;
18404 int res1 = 0 ;
18405 PyObject *swig_obj[1] ;
18406
18407 if (!args) SWIG_fail;
18408 swig_obj[0] = args;
18409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18410 if (!SWIG_IsOK(res1)) {
18411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18412 }
18413 arg1 = reinterpret_cast< wxEvent * >(argp1);
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 {
18421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18422 }
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj = 0;
18431 wxEvent *arg1 = (wxEvent *) 0 ;
18432 bool arg2 = (bool) true ;
18433 void *argp1 = 0 ;
18434 int res1 = 0 ;
18435 bool val2 ;
18436 int ecode2 = 0 ;
18437 PyObject * obj0 = 0 ;
18438 PyObject * obj1 = 0 ;
18439 char * kwnames[] = {
18440 (char *) "self",(char *) "skip", NULL
18441 };
18442
18443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18447 }
18448 arg1 = reinterpret_cast< wxEvent * >(argp1);
18449 if (obj1) {
18450 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18451 if (!SWIG_IsOK(ecode2)) {
18452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18453 }
18454 arg2 = static_cast< bool >(val2);
18455 }
18456 {
18457 PyThreadState* __tstate = wxPyBeginAllowThreads();
18458 (arg1)->Skip(arg2);
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 resultobj = SWIG_Py_Void();
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18470 PyObject *resultobj = 0;
18471 wxEvent *arg1 = (wxEvent *) 0 ;
18472 bool result;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 PyObject *swig_obj[1] ;
18476
18477 if (!args) SWIG_fail;
18478 swig_obj[0] = args;
18479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18482 }
18483 arg1 = reinterpret_cast< wxEvent * >(argp1);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 {
18491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18492 }
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18500 PyObject *resultobj = 0;
18501 wxEvent *arg1 = (wxEvent *) 0 ;
18502 bool result;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 PyObject *swig_obj[1] ;
18506
18507 if (!args) SWIG_fail;
18508 swig_obj[0] = args;
18509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18512 }
18513 arg1 = reinterpret_cast< wxEvent * >(argp1);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *resultobj = 0;
18531 wxEvent *arg1 = (wxEvent *) 0 ;
18532 int result;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 PyObject *swig_obj[1] ;
18536
18537 if (!args) SWIG_fail;
18538 swig_obj[0] = args;
18539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18542 }
18543 arg1 = reinterpret_cast< wxEvent * >(argp1);
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (int)(arg1)->StopPropagation();
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 resultobj = SWIG_From_int(static_cast< int >(result));
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj = 0;
18559 wxEvent *arg1 = (wxEvent *) 0 ;
18560 int arg2 ;
18561 void *argp1 = 0 ;
18562 int res1 = 0 ;
18563 int val2 ;
18564 int ecode2 = 0 ;
18565 PyObject * obj0 = 0 ;
18566 PyObject * obj1 = 0 ;
18567 char * kwnames[] = {
18568 (char *) "self",(char *) "propagationLevel", NULL
18569 };
18570
18571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18573 if (!SWIG_IsOK(res1)) {
18574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18575 }
18576 arg1 = reinterpret_cast< wxEvent * >(argp1);
18577 ecode2 = SWIG_AsVal_int(obj1, &val2);
18578 if (!SWIG_IsOK(ecode2)) {
18579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18580 }
18581 arg2 = static_cast< int >(val2);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 (arg1)->ResumePropagation(arg2);
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_Py_Void();
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxEvent *arg1 = (wxEvent *) 0 ;
18598 wxEvent *result = 0 ;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18608 }
18609 arg1 = reinterpret_cast< wxEvent * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (wxEvent *)(arg1)->Clone();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18624 PyObject *obj;
18625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18626 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18627 return SWIG_Py_Void();
18628 }
18629
18630 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj = 0;
18632 wxEvent *arg1 = 0 ;
18633 wxPropagationDisabler *result = 0 ;
18634 void *argp1 = 0 ;
18635 int res1 = 0 ;
18636 PyObject * obj0 = 0 ;
18637 char * kwnames[] = {
18638 (char *) "event", NULL
18639 };
18640
18641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18642 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18643 if (!SWIG_IsOK(res1)) {
18644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18645 }
18646 if (!argp1) {
18647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18648 }
18649 arg1 = reinterpret_cast< wxEvent * >(argp1);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18675 }
18676 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 delete arg1;
18680
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 resultobj = SWIG_Py_Void();
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18692 PyObject *obj;
18693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18694 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18695 return SWIG_Py_Void();
18696 }
18697
18698 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18699 return SWIG_Python_InitShadowInstance(args);
18700 }
18701
18702 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj = 0;
18704 wxEvent *arg1 = 0 ;
18705 wxPropagateOnce *result = 0 ;
18706 void *argp1 = 0 ;
18707 int res1 = 0 ;
18708 PyObject * obj0 = 0 ;
18709 char * kwnames[] = {
18710 (char *) "event", NULL
18711 };
18712
18713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18714 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18715 if (!SWIG_IsOK(res1)) {
18716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18717 }
18718 if (!argp1) {
18719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18720 }
18721 arg1 = reinterpret_cast< wxEvent * >(argp1);
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18736 PyObject *resultobj = 0;
18737 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18747 }
18748 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 delete arg1;
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 resultobj = SWIG_Py_Void();
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 PyObject *obj;
18765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18767 return SWIG_Py_Void();
18768 }
18769
18770 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 return SWIG_Python_InitShadowInstance(args);
18772 }
18773
18774 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj = 0;
18776 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18777 int arg2 = (int) 0 ;
18778 wxCommandEvent *result = 0 ;
18779 int val1 ;
18780 int ecode1 = 0 ;
18781 int val2 ;
18782 int ecode2 = 0 ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "commandType",(char *) "winid", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18790 if (obj0) {
18791 ecode1 = SWIG_AsVal_int(obj0, &val1);
18792 if (!SWIG_IsOK(ecode1)) {
18793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18794 }
18795 arg1 = static_cast< wxEventType >(val1);
18796 }
18797 if (obj1) {
18798 ecode2 = SWIG_AsVal_int(obj1, &val2);
18799 if (!SWIG_IsOK(ecode2)) {
18800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18801 }
18802 arg2 = static_cast< int >(val2);
18803 }
18804 {
18805 PyThreadState* __tstate = wxPyBeginAllowThreads();
18806 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18807 wxPyEndAllowThreads(__tstate);
18808 if (PyErr_Occurred()) SWIG_fail;
18809 }
18810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18811 return resultobj;
18812 fail:
18813 return NULL;
18814 }
18815
18816
18817 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18818 PyObject *resultobj = 0;
18819 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18820 int result;
18821 void *argp1 = 0 ;
18822 int res1 = 0 ;
18823 PyObject *swig_obj[1] ;
18824
18825 if (!args) SWIG_fail;
18826 swig_obj[0] = args;
18827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18830 }
18831 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18835 wxPyEndAllowThreads(__tstate);
18836 if (PyErr_Occurred()) SWIG_fail;
18837 }
18838 resultobj = SWIG_From_int(static_cast< int >(result));
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj = 0;
18847 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18848 wxString *arg2 = 0 ;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 bool temp2 = false ;
18852 PyObject * obj0 = 0 ;
18853 PyObject * obj1 = 0 ;
18854 char * kwnames[] = {
18855 (char *) "self",(char *) "s", NULL
18856 };
18857
18858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18860 if (!SWIG_IsOK(res1)) {
18861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18862 }
18863 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18864 {
18865 arg2 = wxString_in_helper(obj1);
18866 if (arg2 == NULL) SWIG_fail;
18867 temp2 = true;
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 (arg1)->SetString((wxString const &)*arg2);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_Py_Void();
18876 {
18877 if (temp2)
18878 delete arg2;
18879 }
18880 return resultobj;
18881 fail:
18882 {
18883 if (temp2)
18884 delete arg2;
18885 }
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891 PyObject *resultobj = 0;
18892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18893 wxString result;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 PyObject *swig_obj[1] ;
18897
18898 if (!args) SWIG_fail;
18899 swig_obj[0] = args;
18900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18901 if (!SWIG_IsOK(res1)) {
18902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18903 }
18904 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 result = ((wxCommandEvent const *)arg1)->GetString();
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 {
18912 #if wxUSE_UNICODE
18913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18914 #else
18915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18916 #endif
18917 }
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18925 PyObject *resultobj = 0;
18926 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18927 bool result;
18928 void *argp1 = 0 ;
18929 int res1 = 0 ;
18930 PyObject *swig_obj[1] ;
18931
18932 if (!args) SWIG_fail;
18933 swig_obj[0] = args;
18934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18939 {
18940 PyThreadState* __tstate = wxPyBeginAllowThreads();
18941 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18942 wxPyEndAllowThreads(__tstate);
18943 if (PyErr_Occurred()) SWIG_fail;
18944 }
18945 {
18946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18947 }
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18955 PyObject *resultobj = 0;
18956 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18957 bool result;
18958 void *argp1 = 0 ;
18959 int res1 = 0 ;
18960 PyObject *swig_obj[1] ;
18961
18962 if (!args) SWIG_fail;
18963 swig_obj[0] = args;
18964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18965 if (!SWIG_IsOK(res1)) {
18966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18967 }
18968 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 {
18976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18977 }
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj = 0;
18986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18987 long arg2 ;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 long val2 ;
18991 int ecode2 = 0 ;
18992 PyObject * obj0 = 0 ;
18993 PyObject * obj1 = 0 ;
18994 char * kwnames[] = {
18995 (char *) "self",(char *) "extraLong", NULL
18996 };
18997
18998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19002 }
19003 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19004 ecode2 = SWIG_AsVal_long(obj1, &val2);
19005 if (!SWIG_IsOK(ecode2)) {
19006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19007 }
19008 arg2 = static_cast< long >(val2);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 (arg1)->SetExtraLong(arg2);
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_Py_Void();
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 long result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = SWIG_From_long(static_cast< long >(result));
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 int arg2 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 int val2 ;
19057 int ecode2 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "i", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",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_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19070 ecode2 = SWIG_AsVal_int(obj1, &val2);
19071 if (!SWIG_IsOK(ecode2)) {
19072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19073 }
19074 arg2 = static_cast< int >(val2);
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 (arg1)->SetInt(arg2);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 resultobj = SWIG_Py_Void();
19082 return resultobj;
19083 fail:
19084 return NULL;
19085 }
19086
19087
19088 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 PyObject *resultobj = 0;
19090 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19091 long result;
19092 void *argp1 = 0 ;
19093 int res1 = 0 ;
19094 PyObject *swig_obj[1] ;
19095
19096 if (!args) SWIG_fail;
19097 swig_obj[0] = args;
19098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19099 if (!SWIG_IsOK(res1)) {
19100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19101 }
19102 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_From_long(static_cast< long >(result));
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117 PyObject *resultobj = 0;
19118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19119 PyObject *result = 0 ;
19120 void *argp1 = 0 ;
19121 int res1 = 0 ;
19122 PyObject *swig_obj[1] ;
19123
19124 if (!args) SWIG_fail;
19125 swig_obj[0] = args;
19126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19127 if (!SWIG_IsOK(res1)) {
19128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19129 }
19130 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 resultobj = result;
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj = 0;
19146 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19147 PyObject *arg2 = (PyObject *) 0 ;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 PyObject * obj0 = 0 ;
19151 PyObject * obj1 = 0 ;
19152 char * kwnames[] = {
19153 (char *) "self",(char *) "clientData", NULL
19154 };
19155
19156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19158 if (!SWIG_IsOK(res1)) {
19159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19160 }
19161 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19162 arg2 = obj1;
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 wxCommandEvent_SetClientData(arg1,arg2);
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_Py_Void();
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177 PyObject *resultobj = 0;
19178 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19179 wxEvent *result = 0 ;
19180 void *argp1 = 0 ;
19181 int res1 = 0 ;
19182 PyObject *swig_obj[1] ;
19183
19184 if (!args) SWIG_fail;
19185 swig_obj[0] = args;
19186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19187 if (!SWIG_IsOK(res1)) {
19188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19189 }
19190 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19205 PyObject *obj;
19206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19207 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19208 return SWIG_Py_Void();
19209 }
19210
19211 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19212 return SWIG_Python_InitShadowInstance(args);
19213 }
19214
19215 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj = 0;
19217 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19218 int arg2 = (int) 0 ;
19219 wxNotifyEvent *result = 0 ;
19220 int val1 ;
19221 int ecode1 = 0 ;
19222 int val2 ;
19223 int ecode2 = 0 ;
19224 PyObject * obj0 = 0 ;
19225 PyObject * obj1 = 0 ;
19226 char * kwnames[] = {
19227 (char *) "commandType",(char *) "winid", NULL
19228 };
19229
19230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19231 if (obj0) {
19232 ecode1 = SWIG_AsVal_int(obj0, &val1);
19233 if (!SWIG_IsOK(ecode1)) {
19234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19235 }
19236 arg1 = static_cast< wxEventType >(val1);
19237 }
19238 if (obj1) {
19239 ecode2 = SWIG_AsVal_int(obj1, &val2);
19240 if (!SWIG_IsOK(ecode2)) {
19241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19242 }
19243 arg2 = static_cast< int >(val2);
19244 }
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19259 PyObject *resultobj = 0;
19260 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject *swig_obj[1] ;
19264
19265 if (!args) SWIG_fail;
19266 swig_obj[0] = args;
19267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19268 if (!SWIG_IsOK(res1)) {
19269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19270 }
19271 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 (arg1)->Veto();
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_Py_Void();
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19286 PyObject *resultobj = 0;
19287 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 PyObject *swig_obj[1] ;
19291
19292 if (!args) SWIG_fail;
19293 swig_obj[0] = args;
19294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19297 }
19298 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 (arg1)->Allow();
19302 wxPyEndAllowThreads(__tstate);
19303 if (PyErr_Occurred()) SWIG_fail;
19304 }
19305 resultobj = SWIG_Py_Void();
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19313 PyObject *resultobj = 0;
19314 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19315 bool result;
19316 void *argp1 = 0 ;
19317 int res1 = 0 ;
19318 PyObject *swig_obj[1] ;
19319
19320 if (!args) SWIG_fail;
19321 swig_obj[0] = args;
19322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19325 }
19326 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 result = (bool)(arg1)->IsAllowed();
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 {
19334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19335 }
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19343 PyObject *obj;
19344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19345 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19346 return SWIG_Py_Void();
19347 }
19348
19349 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19350 return SWIG_Python_InitShadowInstance(args);
19351 }
19352
19353 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19356 int arg2 = (int) 0 ;
19357 int arg3 = (int) 0 ;
19358 int arg4 = (int) 0 ;
19359 wxScrollEvent *result = 0 ;
19360 int val1 ;
19361 int ecode1 = 0 ;
19362 int val2 ;
19363 int ecode2 = 0 ;
19364 int val3 ;
19365 int ecode3 = 0 ;
19366 int val4 ;
19367 int ecode4 = 0 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 PyObject * obj2 = 0 ;
19371 PyObject * obj3 = 0 ;
19372 char * kwnames[] = {
19373 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19374 };
19375
19376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19377 if (obj0) {
19378 ecode1 = SWIG_AsVal_int(obj0, &val1);
19379 if (!SWIG_IsOK(ecode1)) {
19380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19381 }
19382 arg1 = static_cast< wxEventType >(val1);
19383 }
19384 if (obj1) {
19385 ecode2 = SWIG_AsVal_int(obj1, &val2);
19386 if (!SWIG_IsOK(ecode2)) {
19387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19388 }
19389 arg2 = static_cast< int >(val2);
19390 }
19391 if (obj2) {
19392 ecode3 = SWIG_AsVal_int(obj2, &val3);
19393 if (!SWIG_IsOK(ecode3)) {
19394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19395 }
19396 arg3 = static_cast< int >(val3);
19397 }
19398 if (obj3) {
19399 ecode4 = SWIG_AsVal_int(obj3, &val4);
19400 if (!SWIG_IsOK(ecode4)) {
19401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19402 }
19403 arg4 = static_cast< int >(val4);
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19419 PyObject *resultobj = 0;
19420 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19421 int result;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject *swig_obj[1] ;
19425
19426 if (!args) SWIG_fail;
19427 swig_obj[0] = args;
19428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19429 if (!SWIG_IsOK(res1)) {
19430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19431 }
19432 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 resultobj = SWIG_From_int(static_cast< int >(result));
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 PyObject *resultobj = 0;
19448 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19449 int result;
19450 void *argp1 = 0 ;
19451 int res1 = 0 ;
19452 PyObject *swig_obj[1] ;
19453
19454 if (!args) SWIG_fail;
19455 swig_obj[0] = args;
19456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19459 }
19460 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 resultobj = SWIG_From_int(static_cast< int >(result));
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj = 0;
19476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19477 int arg2 ;
19478 void *argp1 = 0 ;
19479 int res1 = 0 ;
19480 int val2 ;
19481 int ecode2 = 0 ;
19482 PyObject * obj0 = 0 ;
19483 PyObject * obj1 = 0 ;
19484 char * kwnames[] = {
19485 (char *) "self",(char *) "orient", NULL
19486 };
19487
19488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19490 if (!SWIG_IsOK(res1)) {
19491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19492 }
19493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19494 ecode2 = SWIG_AsVal_int(obj1, &val2);
19495 if (!SWIG_IsOK(ecode2)) {
19496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19497 }
19498 arg2 = static_cast< int >(val2);
19499 {
19500 PyThreadState* __tstate = wxPyBeginAllowThreads();
19501 (arg1)->SetOrientation(arg2);
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 resultobj = SWIG_Py_Void();
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj = 0;
19514 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19515 int arg2 ;
19516 void *argp1 = 0 ;
19517 int res1 = 0 ;
19518 int val2 ;
19519 int ecode2 = 0 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char * kwnames[] = {
19523 (char *) "self",(char *) "pos", NULL
19524 };
19525
19526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19530 }
19531 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19532 ecode2 = SWIG_AsVal_int(obj1, &val2);
19533 if (!SWIG_IsOK(ecode2)) {
19534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19535 }
19536 arg2 = static_cast< int >(val2);
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 (arg1)->SetPosition(arg2);
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 resultobj = SWIG_Py_Void();
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19551 PyObject *obj;
19552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19553 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19554 return SWIG_Py_Void();
19555 }
19556
19557 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 return SWIG_Python_InitShadowInstance(args);
19559 }
19560
19561 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj = 0;
19563 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19564 int arg2 = (int) 0 ;
19565 int arg3 = (int) 0 ;
19566 wxScrollWinEvent *result = 0 ;
19567 int val1 ;
19568 int ecode1 = 0 ;
19569 int val2 ;
19570 int ecode2 = 0 ;
19571 int val3 ;
19572 int ecode3 = 0 ;
19573 PyObject * obj0 = 0 ;
19574 PyObject * obj1 = 0 ;
19575 PyObject * obj2 = 0 ;
19576 char * kwnames[] = {
19577 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19578 };
19579
19580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19581 if (obj0) {
19582 ecode1 = SWIG_AsVal_int(obj0, &val1);
19583 if (!SWIG_IsOK(ecode1)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19585 }
19586 arg1 = static_cast< wxEventType >(val1);
19587 }
19588 if (obj1) {
19589 ecode2 = SWIG_AsVal_int(obj1, &val2);
19590 if (!SWIG_IsOK(ecode2)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19592 }
19593 arg2 = static_cast< int >(val2);
19594 }
19595 if (obj2) {
19596 ecode3 = SWIG_AsVal_int(obj2, &val3);
19597 if (!SWIG_IsOK(ecode3)) {
19598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19599 }
19600 arg3 = static_cast< int >(val3);
19601 }
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19616 PyObject *resultobj = 0;
19617 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19618 int result;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 PyObject *swig_obj[1] ;
19622
19623 if (!args) SWIG_fail;
19624 swig_obj[0] = args;
19625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19628 }
19629 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_From_int(static_cast< int >(result));
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 PyObject *resultobj = 0;
19645 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19646 int result;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 PyObject *swig_obj[1] ;
19650
19651 if (!args) SWIG_fail;
19652 swig_obj[0] = args;
19653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19654 if (!SWIG_IsOK(res1)) {
19655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19656 }
19657 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_From_int(static_cast< int >(result));
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj = 0;
19673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19674 int arg2 ;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 int val2 ;
19678 int ecode2 = 0 ;
19679 PyObject * obj0 = 0 ;
19680 PyObject * obj1 = 0 ;
19681 char * kwnames[] = {
19682 (char *) "self",(char *) "orient", NULL
19683 };
19684
19685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19687 if (!SWIG_IsOK(res1)) {
19688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19689 }
19690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19691 ecode2 = SWIG_AsVal_int(obj1, &val2);
19692 if (!SWIG_IsOK(ecode2)) {
19693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19694 }
19695 arg2 = static_cast< int >(val2);
19696 {
19697 PyThreadState* __tstate = wxPyBeginAllowThreads();
19698 (arg1)->SetOrientation(arg2);
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_Py_Void();
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj = 0;
19711 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19712 int arg2 ;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 int val2 ;
19716 int ecode2 = 0 ;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char * kwnames[] = {
19720 (char *) "self",(char *) "pos", NULL
19721 };
19722
19723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19725 if (!SWIG_IsOK(res1)) {
19726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19727 }
19728 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19729 ecode2 = SWIG_AsVal_int(obj1, &val2);
19730 if (!SWIG_IsOK(ecode2)) {
19731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19732 }
19733 arg2 = static_cast< int >(val2);
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 (arg1)->SetPosition(arg2);
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_Py_Void();
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19748 PyObject *obj;
19749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19750 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19751 return SWIG_Py_Void();
19752 }
19753
19754 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19755 return SWIG_Python_InitShadowInstance(args);
19756 }
19757
19758 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19759 PyObject *resultobj = 0;
19760 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19761 wxMouseEvent *result = 0 ;
19762 int val1 ;
19763 int ecode1 = 0 ;
19764 PyObject * obj0 = 0 ;
19765 char * kwnames[] = {
19766 (char *) "mouseType", NULL
19767 };
19768
19769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19770 if (obj0) {
19771 ecode1 = SWIG_AsVal_int(obj0, &val1);
19772 if (!SWIG_IsOK(ecode1)) {
19773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19774 }
19775 arg1 = static_cast< wxEventType >(val1);
19776 }
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 {
19784 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19785 }
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793 PyObject *resultobj = 0;
19794 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19795 bool result;
19796 void *argp1 = 0 ;
19797 int res1 = 0 ;
19798 PyObject *swig_obj[1] ;
19799
19800 if (!args) SWIG_fail;
19801 swig_obj[0] = args;
19802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19803 if (!SWIG_IsOK(res1)) {
19804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19805 }
19806 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19810 wxPyEndAllowThreads(__tstate);
19811 if (PyErr_Occurred()) SWIG_fail;
19812 }
19813 {
19814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19815 }
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19825 int arg2 = (int) wxMOUSE_BTN_ANY ;
19826 bool result;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 int val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "but", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19841 }
19842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19843 if (obj1) {
19844 ecode2 = SWIG_AsVal_int(obj1, &val2);
19845 if (!SWIG_IsOK(ecode2)) {
19846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19847 }
19848 arg2 = static_cast< int >(val2);
19849 }
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 {
19857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19858 }
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = 0;
19867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19868 int arg2 = (int) wxMOUSE_BTN_ANY ;
19869 bool result;
19870 void *argp1 = 0 ;
19871 int res1 = 0 ;
19872 int val2 ;
19873 int ecode2 = 0 ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char * kwnames[] = {
19877 (char *) "self",(char *) "but", NULL
19878 };
19879
19880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19882 if (!SWIG_IsOK(res1)) {
19883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19884 }
19885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19886 if (obj1) {
19887 ecode2 = SWIG_AsVal_int(obj1, &val2);
19888 if (!SWIG_IsOK(ecode2)) {
19889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19890 }
19891 arg2 = static_cast< int >(val2);
19892 }
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 {
19900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19901 }
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj = 0;
19910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19911 int arg2 = (int) wxMOUSE_BTN_ANY ;
19912 bool result;
19913 void *argp1 = 0 ;
19914 int res1 = 0 ;
19915 int val2 ;
19916 int ecode2 = 0 ;
19917 PyObject * obj0 = 0 ;
19918 PyObject * obj1 = 0 ;
19919 char * kwnames[] = {
19920 (char *) "self",(char *) "but", NULL
19921 };
19922
19923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19927 }
19928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19929 if (obj1) {
19930 ecode2 = SWIG_AsVal_int(obj1, &val2);
19931 if (!SWIG_IsOK(ecode2)) {
19932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19933 }
19934 arg2 = static_cast< int >(val2);
19935 }
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19939 wxPyEndAllowThreads(__tstate);
19940 if (PyErr_Occurred()) SWIG_fail;
19941 }
19942 {
19943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19944 }
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj = 0;
19953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19954 int arg2 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 int val2 ;
19959 int ecode2 = 0 ;
19960 PyObject * obj0 = 0 ;
19961 PyObject * obj1 = 0 ;
19962 char * kwnames[] = {
19963 (char *) "self",(char *) "button", NULL
19964 };
19965
19966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19968 if (!SWIG_IsOK(res1)) {
19969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19970 }
19971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19972 ecode2 = SWIG_AsVal_int(obj1, &val2);
19973 if (!SWIG_IsOK(ecode2)) {
19974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19975 }
19976 arg2 = static_cast< int >(val2);
19977 {
19978 PyThreadState* __tstate = wxPyBeginAllowThreads();
19979 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19980 wxPyEndAllowThreads(__tstate);
19981 if (PyErr_Occurred()) SWIG_fail;
19982 }
19983 {
19984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19985 }
19986 return resultobj;
19987 fail:
19988 return NULL;
19989 }
19990
19991
19992 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj = 0;
19994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19995 int arg2 ;
19996 bool result;
19997 void *argp1 = 0 ;
19998 int res1 = 0 ;
19999 int val2 ;
20000 int ecode2 = 0 ;
20001 PyObject * obj0 = 0 ;
20002 PyObject * obj1 = 0 ;
20003 char * kwnames[] = {
20004 (char *) "self",(char *) "but", NULL
20005 };
20006
20007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20009 if (!SWIG_IsOK(res1)) {
20010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20011 }
20012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20013 ecode2 = SWIG_AsVal_int(obj1, &val2);
20014 if (!SWIG_IsOK(ecode2)) {
20015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20016 }
20017 arg2 = static_cast< int >(val2);
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 {
20025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20026 }
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20034 PyObject *resultobj = 0;
20035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20036 int result;
20037 void *argp1 = 0 ;
20038 int res1 = 0 ;
20039 PyObject *swig_obj[1] ;
20040
20041 if (!args) SWIG_fail;
20042 swig_obj[0] = args;
20043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20044 if (!SWIG_IsOK(res1)) {
20045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20046 }
20047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 resultobj = SWIG_From_int(static_cast< int >(result));
20055 return resultobj;
20056 fail:
20057 return NULL;
20058 }
20059
20060
20061 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20062 PyObject *resultobj = 0;
20063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20064 bool result;
20065 void *argp1 = 0 ;
20066 int res1 = 0 ;
20067 PyObject *swig_obj[1] ;
20068
20069 if (!args) SWIG_fail;
20070 swig_obj[0] = args;
20071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20072 if (!SWIG_IsOK(res1)) {
20073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20074 }
20075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 {
20083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20084 }
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20092 PyObject *resultobj = 0;
20093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20094 bool result;
20095 void *argp1 = 0 ;
20096 int res1 = 0 ;
20097 PyObject *swig_obj[1] ;
20098
20099 if (!args) SWIG_fail;
20100 swig_obj[0] = args;
20101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20102 if (!SWIG_IsOK(res1)) {
20103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20104 }
20105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20106 {
20107 PyThreadState* __tstate = wxPyBeginAllowThreads();
20108 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 {
20113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20122 PyObject *resultobj = 0;
20123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20124 bool result;
20125 void *argp1 = 0 ;
20126 int res1 = 0 ;
20127 PyObject *swig_obj[1] ;
20128
20129 if (!args) SWIG_fail;
20130 swig_obj[0] = args;
20131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20132 if (!SWIG_IsOK(res1)) {
20133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20134 }
20135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20139 wxPyEndAllowThreads(__tstate);
20140 if (PyErr_Occurred()) SWIG_fail;
20141 }
20142 {
20143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20144 }
20145 return resultobj;
20146 fail:
20147 return NULL;
20148 }
20149
20150
20151 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20152 PyObject *resultobj = 0;
20153 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20154 bool result;
20155 void *argp1 = 0 ;
20156 int res1 = 0 ;
20157 PyObject *swig_obj[1] ;
20158
20159 if (!args) SWIG_fail;
20160 swig_obj[0] = args;
20161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20162 if (!SWIG_IsOK(res1)) {
20163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20164 }
20165 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 {
20173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20174 }
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 PyObject *resultobj = 0;
20183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20184 bool result;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 PyObject *swig_obj[1] ;
20188
20189 if (!args) SWIG_fail;
20190 swig_obj[0] = args;
20191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20194 }
20195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 {
20203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20204 }
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 PyObject *resultobj = 0;
20213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20214 bool result;
20215 void *argp1 = 0 ;
20216 int res1 = 0 ;
20217 PyObject *swig_obj[1] ;
20218
20219 if (!args) SWIG_fail;
20220 swig_obj[0] = args;
20221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20222 if (!SWIG_IsOK(res1)) {
20223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20224 }
20225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20226 {
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 {
20233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20234 }
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 PyObject *resultobj = 0;
20243 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20244 bool result;
20245 void *argp1 = 0 ;
20246 int res1 = 0 ;
20247 PyObject *swig_obj[1] ;
20248
20249 if (!args) SWIG_fail;
20250 swig_obj[0] = args;
20251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20252 if (!SWIG_IsOK(res1)) {
20253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20254 }
20255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20259 wxPyEndAllowThreads(__tstate);
20260 if (PyErr_Occurred()) SWIG_fail;
20261 }
20262 {
20263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20264 }
20265 return resultobj;
20266 fail:
20267 return NULL;
20268 }
20269
20270
20271 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272 PyObject *resultobj = 0;
20273 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20274 bool result;
20275 void *argp1 = 0 ;
20276 int res1 = 0 ;
20277 PyObject *swig_obj[1] ;
20278
20279 if (!args) SWIG_fail;
20280 swig_obj[0] = args;
20281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20282 if (!SWIG_IsOK(res1)) {
20283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20284 }
20285 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 {
20293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20294 }
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20302 PyObject *resultobj = 0;
20303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20304 bool result;
20305 void *argp1 = 0 ;
20306 int res1 = 0 ;
20307 PyObject *swig_obj[1] ;
20308
20309 if (!args) SWIG_fail;
20310 swig_obj[0] = args;
20311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20312 if (!SWIG_IsOK(res1)) {
20313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20314 }
20315 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 {
20323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20324 }
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20334 bool result;
20335 void *argp1 = 0 ;
20336 int res1 = 0 ;
20337 PyObject *swig_obj[1] ;
20338
20339 if (!args) SWIG_fail;
20340 swig_obj[0] = args;
20341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20344 }
20345 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20346 {
20347 PyThreadState* __tstate = wxPyBeginAllowThreads();
20348 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 {
20353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20354 }
20355 return resultobj;
20356 fail:
20357 return NULL;
20358 }
20359
20360
20361 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20364 bool result;
20365 void *argp1 = 0 ;
20366 int res1 = 0 ;
20367 PyObject *swig_obj[1] ;
20368
20369 if (!args) SWIG_fail;
20370 swig_obj[0] = args;
20371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20372 if (!SWIG_IsOK(res1)) {
20373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20374 }
20375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20376 {
20377 PyThreadState* __tstate = wxPyBeginAllowThreads();
20378 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 {
20383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20384 }
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20392 PyObject *resultobj = 0;
20393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20394 bool result;
20395 void *argp1 = 0 ;
20396 int res1 = 0 ;
20397 PyObject *swig_obj[1] ;
20398
20399 if (!args) SWIG_fail;
20400 swig_obj[0] = args;
20401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20402 if (!SWIG_IsOK(res1)) {
20403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20404 }
20405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 {
20413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20414 }
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *resultobj = 0;
20423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20424 bool result;
20425 void *argp1 = 0 ;
20426 int res1 = 0 ;
20427 PyObject *swig_obj[1] ;
20428
20429 if (!args) SWIG_fail;
20430 swig_obj[0] = args;
20431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20432 if (!SWIG_IsOK(res1)) {
20433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20434 }
20435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 {
20443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20444 }
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20452 PyObject *resultobj = 0;
20453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20454 bool result;
20455 void *argp1 = 0 ;
20456 int res1 = 0 ;
20457 PyObject *swig_obj[1] ;
20458
20459 if (!args) SWIG_fail;
20460 swig_obj[0] = args;
20461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20462 if (!SWIG_IsOK(res1)) {
20463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20464 }
20465 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 {
20473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20474 }
20475 return resultobj;
20476 fail:
20477 return NULL;
20478 }
20479
20480
20481 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20482 PyObject *resultobj = 0;
20483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20484 bool result;
20485 void *argp1 = 0 ;
20486 int res1 = 0 ;
20487 PyObject *swig_obj[1] ;
20488
20489 if (!args) SWIG_fail;
20490 swig_obj[0] = args;
20491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20492 if (!SWIG_IsOK(res1)) {
20493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20494 }
20495 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20496 {
20497 PyThreadState* __tstate = wxPyBeginAllowThreads();
20498 result = (bool)(arg1)->LeftIsDown();
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 {
20503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20504 }
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20512 PyObject *resultobj = 0;
20513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20514 bool result;
20515 void *argp1 = 0 ;
20516 int res1 = 0 ;
20517 PyObject *swig_obj[1] ;
20518
20519 if (!args) SWIG_fail;
20520 swig_obj[0] = args;
20521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20524 }
20525 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (bool)(arg1)->MiddleIsDown();
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 {
20533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20534 }
20535 return resultobj;
20536 fail:
20537 return NULL;
20538 }
20539
20540
20541 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20542 PyObject *resultobj = 0;
20543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20544 bool result;
20545 void *argp1 = 0 ;
20546 int res1 = 0 ;
20547 PyObject *swig_obj[1] ;
20548
20549 if (!args) SWIG_fail;
20550 swig_obj[0] = args;
20551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20552 if (!SWIG_IsOK(res1)) {
20553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20554 }
20555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20556 {
20557 PyThreadState* __tstate = wxPyBeginAllowThreads();
20558 result = (bool)(arg1)->RightIsDown();
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20564 }
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20572 PyObject *resultobj = 0;
20573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20574 bool result;
20575 void *argp1 = 0 ;
20576 int res1 = 0 ;
20577 PyObject *swig_obj[1] ;
20578
20579 if (!args) SWIG_fail;
20580 swig_obj[0] = args;
20581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20584 }
20585 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20604 bool result;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject *swig_obj[1] ;
20608
20609 if (!args) SWIG_fail;
20610 swig_obj[0] = args;
20611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20614 }
20615 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20632 PyObject *resultobj = 0;
20633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20634 bool result;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 PyObject *swig_obj[1] ;
20638
20639 if (!args) SWIG_fail;
20640 swig_obj[0] = args;
20641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20642 if (!SWIG_IsOK(res1)) {
20643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20644 }
20645 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20646 {
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20654 }
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20662 PyObject *resultobj = 0;
20663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20664 bool result;
20665 void *argp1 = 0 ;
20666 int res1 = 0 ;
20667 PyObject *swig_obj[1] ;
20668
20669 if (!args) SWIG_fail;
20670 swig_obj[0] = args;
20671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20672 if (!SWIG_IsOK(res1)) {
20673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20674 }
20675 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 {
20683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20684 }
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20692 PyObject *resultobj = 0;
20693 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20694 wxPoint result;
20695 void *argp1 = 0 ;
20696 int res1 = 0 ;
20697 PyObject *swig_obj[1] ;
20698
20699 if (!args) SWIG_fail;
20700 swig_obj[0] = args;
20701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20704 }
20705 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (arg1)->GetPosition();
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20720 PyObject *resultobj = 0;
20721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20722 long *arg2 = (long *) 0 ;
20723 long *arg3 = (long *) 0 ;
20724 void *argp1 = 0 ;
20725 int res1 = 0 ;
20726 long temp2 ;
20727 int res2 = SWIG_TMPOBJ ;
20728 long temp3 ;
20729 int res3 = SWIG_TMPOBJ ;
20730 PyObject *swig_obj[1] ;
20731
20732 arg2 = &temp2;
20733 arg3 = &temp3;
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20739 }
20740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 (arg1)->GetPosition(arg2,arg3);
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 resultobj = SWIG_Py_Void();
20748 if (SWIG_IsTmpObj(res2)) {
20749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20750 } else {
20751 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20753 }
20754 if (SWIG_IsTmpObj(res3)) {
20755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20756 } else {
20757 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20759 }
20760 return resultobj;
20761 fail:
20762 return NULL;
20763 }
20764
20765
20766 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20767 PyObject *resultobj = 0;
20768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20769 wxDC *arg2 = 0 ;
20770 wxPoint result;
20771 void *argp1 = 0 ;
20772 int res1 = 0 ;
20773 void *argp2 = 0 ;
20774 int res2 = 0 ;
20775 PyObject * obj0 = 0 ;
20776 PyObject * obj1 = 0 ;
20777 char * kwnames[] = {
20778 (char *) "self",(char *) "dc", NULL
20779 };
20780
20781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20783 if (!SWIG_IsOK(res1)) {
20784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20785 }
20786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20788 if (!SWIG_IsOK(res2)) {
20789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20790 }
20791 if (!argp2) {
20792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20793 }
20794 arg2 = reinterpret_cast< wxDC * >(argp2);
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20811 int result;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 PyObject *swig_obj[1] ;
20815
20816 if (!args) SWIG_fail;
20817 swig_obj[0] = args;
20818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20821 }
20822 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 result = (int)((wxMouseEvent const *)arg1)->GetX();
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 resultobj = SWIG_From_int(static_cast< int >(result));
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *resultobj = 0;
20838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20839 int result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 PyObject *swig_obj[1] ;
20843
20844 if (!args) SWIG_fail;
20845 swig_obj[0] = args;
20846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20849 }
20850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (int)((wxMouseEvent const *)arg1)->GetY();
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 resultobj = SWIG_From_int(static_cast< int >(result));
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20867 int result;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 PyObject *swig_obj[1] ;
20871
20872 if (!args) SWIG_fail;
20873 swig_obj[0] = args;
20874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20875 if (!SWIG_IsOK(res1)) {
20876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20877 }
20878 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_From_int(static_cast< int >(result));
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20893 PyObject *resultobj = 0;
20894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20895 int result;
20896 void *argp1 = 0 ;
20897 int res1 = 0 ;
20898 PyObject *swig_obj[1] ;
20899
20900 if (!args) SWIG_fail;
20901 swig_obj[0] = args;
20902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20903 if (!SWIG_IsOK(res1)) {
20904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20905 }
20906 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_From_int(static_cast< int >(result));
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 PyObject *resultobj = 0;
20922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20923 int result;
20924 void *argp1 = 0 ;
20925 int res1 = 0 ;
20926 PyObject *swig_obj[1] ;
20927
20928 if (!args) SWIG_fail;
20929 swig_obj[0] = args;
20930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20931 if (!SWIG_IsOK(res1)) {
20932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20933 }
20934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_From_int(static_cast< int >(result));
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20961 }
20962 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 {
20970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20971 }
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 int arg2 ;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 int val2 ;
20985 int ecode2 = 0 ;
20986 PyObject *swig_obj[2] ;
20987
20988 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20992 }
20993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20994 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20995 if (!SWIG_IsOK(ecode2)) {
20996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20997 }
20998 arg2 = static_cast< int >(val2);
20999 if (arg1) (arg1)->m_x = arg2;
21000
21001 resultobj = SWIG_Py_Void();
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21009 PyObject *resultobj = 0;
21010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21011 int result;
21012 void *argp1 = 0 ;
21013 int res1 = 0 ;
21014 PyObject *swig_obj[1] ;
21015
21016 if (!args) SWIG_fail;
21017 swig_obj[0] = args;
21018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21019 if (!SWIG_IsOK(res1)) {
21020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21021 }
21022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21023 result = (int) ((arg1)->m_x);
21024 resultobj = SWIG_From_int(static_cast< int >(result));
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21032 PyObject *resultobj = 0;
21033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21034 int arg2 ;
21035 void *argp1 = 0 ;
21036 int res1 = 0 ;
21037 int val2 ;
21038 int ecode2 = 0 ;
21039 PyObject *swig_obj[2] ;
21040
21041 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21045 }
21046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21047 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21048 if (!SWIG_IsOK(ecode2)) {
21049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21050 }
21051 arg2 = static_cast< int >(val2);
21052 if (arg1) (arg1)->m_y = arg2;
21053
21054 resultobj = SWIG_Py_Void();
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 int result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 result = (int) ((arg1)->m_y);
21077 resultobj = SWIG_From_int(static_cast< int >(result));
21078 return resultobj;
21079 fail:
21080 return NULL;
21081 }
21082
21083
21084 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21085 PyObject *resultobj = 0;
21086 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21087 bool arg2 ;
21088 void *argp1 = 0 ;
21089 int res1 = 0 ;
21090 bool val2 ;
21091 int ecode2 = 0 ;
21092 PyObject *swig_obj[2] ;
21093
21094 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21096 if (!SWIG_IsOK(res1)) {
21097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21098 }
21099 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21100 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21101 if (!SWIG_IsOK(ecode2)) {
21102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21103 }
21104 arg2 = static_cast< bool >(val2);
21105 if (arg1) (arg1)->m_leftDown = arg2;
21106
21107 resultobj = SWIG_Py_Void();
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21115 PyObject *resultobj = 0;
21116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21117 bool result;
21118 void *argp1 = 0 ;
21119 int res1 = 0 ;
21120 PyObject *swig_obj[1] ;
21121
21122 if (!args) SWIG_fail;
21123 swig_obj[0] = args;
21124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21127 }
21128 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21129 result = (bool) ((arg1)->m_leftDown);
21130 {
21131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21132 }
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21140 PyObject *resultobj = 0;
21141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21142 bool arg2 ;
21143 void *argp1 = 0 ;
21144 int res1 = 0 ;
21145 bool val2 ;
21146 int ecode2 = 0 ;
21147 PyObject *swig_obj[2] ;
21148
21149 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21151 if (!SWIG_IsOK(res1)) {
21152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21153 }
21154 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21155 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21156 if (!SWIG_IsOK(ecode2)) {
21157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21158 }
21159 arg2 = static_cast< bool >(val2);
21160 if (arg1) (arg1)->m_middleDown = arg2;
21161
21162 resultobj = SWIG_Py_Void();
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21170 PyObject *resultobj = 0;
21171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21172 bool result;
21173 void *argp1 = 0 ;
21174 int res1 = 0 ;
21175 PyObject *swig_obj[1] ;
21176
21177 if (!args) SWIG_fail;
21178 swig_obj[0] = args;
21179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21182 }
21183 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21184 result = (bool) ((arg1)->m_middleDown);
21185 {
21186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21187 }
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21195 PyObject *resultobj = 0;
21196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21197 bool arg2 ;
21198 void *argp1 = 0 ;
21199 int res1 = 0 ;
21200 bool val2 ;
21201 int ecode2 = 0 ;
21202 PyObject *swig_obj[2] ;
21203
21204 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21208 }
21209 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21210 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21211 if (!SWIG_IsOK(ecode2)) {
21212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21213 }
21214 arg2 = static_cast< bool >(val2);
21215 if (arg1) (arg1)->m_rightDown = arg2;
21216
21217 resultobj = SWIG_Py_Void();
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21225 PyObject *resultobj = 0;
21226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21227 bool result;
21228 void *argp1 = 0 ;
21229 int res1 = 0 ;
21230 PyObject *swig_obj[1] ;
21231
21232 if (!args) SWIG_fail;
21233 swig_obj[0] = args;
21234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21235 if (!SWIG_IsOK(res1)) {
21236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21237 }
21238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21239 result = (bool) ((arg1)->m_rightDown);
21240 {
21241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21242 }
21243 return resultobj;
21244 fail:
21245 return NULL;
21246 }
21247
21248
21249 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21250 PyObject *resultobj = 0;
21251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21252 bool arg2 ;
21253 void *argp1 = 0 ;
21254 int res1 = 0 ;
21255 bool val2 ;
21256 int ecode2 = 0 ;
21257 PyObject *swig_obj[2] ;
21258
21259 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21263 }
21264 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21265 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21266 if (!SWIG_IsOK(ecode2)) {
21267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21268 }
21269 arg2 = static_cast< bool >(val2);
21270 if (arg1) (arg1)->m_controlDown = arg2;
21271
21272 resultobj = SWIG_Py_Void();
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21280 PyObject *resultobj = 0;
21281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21282 bool result;
21283 void *argp1 = 0 ;
21284 int res1 = 0 ;
21285 PyObject *swig_obj[1] ;
21286
21287 if (!args) SWIG_fail;
21288 swig_obj[0] = args;
21289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21292 }
21293 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21294 result = (bool) ((arg1)->m_controlDown);
21295 {
21296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21297 }
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21305 PyObject *resultobj = 0;
21306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21307 bool arg2 ;
21308 void *argp1 = 0 ;
21309 int res1 = 0 ;
21310 bool val2 ;
21311 int ecode2 = 0 ;
21312 PyObject *swig_obj[2] ;
21313
21314 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21316 if (!SWIG_IsOK(res1)) {
21317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21318 }
21319 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21320 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21321 if (!SWIG_IsOK(ecode2)) {
21322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21323 }
21324 arg2 = static_cast< bool >(val2);
21325 if (arg1) (arg1)->m_shiftDown = arg2;
21326
21327 resultobj = SWIG_Py_Void();
21328 return resultobj;
21329 fail:
21330 return NULL;
21331 }
21332
21333
21334 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21335 PyObject *resultobj = 0;
21336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 PyObject *swig_obj[1] ;
21341
21342 if (!args) SWIG_fail;
21343 swig_obj[0] = args;
21344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21345 if (!SWIG_IsOK(res1)) {
21346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21347 }
21348 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21349 result = (bool) ((arg1)->m_shiftDown);
21350 {
21351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21352 }
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21360 PyObject *resultobj = 0;
21361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21362 bool arg2 ;
21363 void *argp1 = 0 ;
21364 int res1 = 0 ;
21365 bool val2 ;
21366 int ecode2 = 0 ;
21367 PyObject *swig_obj[2] ;
21368
21369 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21371 if (!SWIG_IsOK(res1)) {
21372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21373 }
21374 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21375 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21376 if (!SWIG_IsOK(ecode2)) {
21377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21378 }
21379 arg2 = static_cast< bool >(val2);
21380 if (arg1) (arg1)->m_altDown = arg2;
21381
21382 resultobj = SWIG_Py_Void();
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21390 PyObject *resultobj = 0;
21391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21392 bool result;
21393 void *argp1 = 0 ;
21394 int res1 = 0 ;
21395 PyObject *swig_obj[1] ;
21396
21397 if (!args) SWIG_fail;
21398 swig_obj[0] = args;
21399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21400 if (!SWIG_IsOK(res1)) {
21401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21402 }
21403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21404 result = (bool) ((arg1)->m_altDown);
21405 {
21406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21407 }
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21415 PyObject *resultobj = 0;
21416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21417 bool arg2 ;
21418 void *argp1 = 0 ;
21419 int res1 = 0 ;
21420 bool val2 ;
21421 int ecode2 = 0 ;
21422 PyObject *swig_obj[2] ;
21423
21424 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21428 }
21429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21430 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21431 if (!SWIG_IsOK(ecode2)) {
21432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21433 }
21434 arg2 = static_cast< bool >(val2);
21435 if (arg1) (arg1)->m_metaDown = arg2;
21436
21437 resultobj = SWIG_Py_Void();
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21445 PyObject *resultobj = 0;
21446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21447 bool result;
21448 void *argp1 = 0 ;
21449 int res1 = 0 ;
21450 PyObject *swig_obj[1] ;
21451
21452 if (!args) SWIG_fail;
21453 swig_obj[0] = args;
21454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21457 }
21458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21459 result = (bool) ((arg1)->m_metaDown);
21460 {
21461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21462 }
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21470 PyObject *resultobj = 0;
21471 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21472 int arg2 ;
21473 void *argp1 = 0 ;
21474 int res1 = 0 ;
21475 int val2 ;
21476 int ecode2 = 0 ;
21477 PyObject *swig_obj[2] ;
21478
21479 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21481 if (!SWIG_IsOK(res1)) {
21482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21483 }
21484 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21485 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21486 if (!SWIG_IsOK(ecode2)) {
21487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21488 }
21489 arg2 = static_cast< int >(val2);
21490 if (arg1) (arg1)->m_wheelRotation = arg2;
21491
21492 resultobj = SWIG_Py_Void();
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21500 PyObject *resultobj = 0;
21501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21502 int result;
21503 void *argp1 = 0 ;
21504 int res1 = 0 ;
21505 PyObject *swig_obj[1] ;
21506
21507 if (!args) SWIG_fail;
21508 swig_obj[0] = args;
21509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21510 if (!SWIG_IsOK(res1)) {
21511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21512 }
21513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21514 result = (int) ((arg1)->m_wheelRotation);
21515 resultobj = SWIG_From_int(static_cast< int >(result));
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21523 PyObject *resultobj = 0;
21524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21525 int arg2 ;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 int val2 ;
21529 int ecode2 = 0 ;
21530 PyObject *swig_obj[2] ;
21531
21532 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21534 if (!SWIG_IsOK(res1)) {
21535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21539 if (!SWIG_IsOK(ecode2)) {
21540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21541 }
21542 arg2 = static_cast< int >(val2);
21543 if (arg1) (arg1)->m_wheelDelta = arg2;
21544
21545 resultobj = SWIG_Py_Void();
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553 PyObject *resultobj = 0;
21554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21555 int result;
21556 void *argp1 = 0 ;
21557 int res1 = 0 ;
21558 PyObject *swig_obj[1] ;
21559
21560 if (!args) SWIG_fail;
21561 swig_obj[0] = args;
21562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21563 if (!SWIG_IsOK(res1)) {
21564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21565 }
21566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21567 result = (int) ((arg1)->m_wheelDelta);
21568 resultobj = SWIG_From_int(static_cast< int >(result));
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21576 PyObject *resultobj = 0;
21577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21578 int arg2 ;
21579 void *argp1 = 0 ;
21580 int res1 = 0 ;
21581 int val2 ;
21582 int ecode2 = 0 ;
21583 PyObject *swig_obj[2] ;
21584
21585 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21587 if (!SWIG_IsOK(res1)) {
21588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21589 }
21590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21591 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21592 if (!SWIG_IsOK(ecode2)) {
21593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21594 }
21595 arg2 = static_cast< int >(val2);
21596 if (arg1) (arg1)->m_linesPerAction = arg2;
21597
21598 resultobj = SWIG_Py_Void();
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21606 PyObject *resultobj = 0;
21607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21608 int result;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 PyObject *swig_obj[1] ;
21612
21613 if (!args) SWIG_fail;
21614 swig_obj[0] = args;
21615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21616 if (!SWIG_IsOK(res1)) {
21617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21618 }
21619 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21620 result = (int) ((arg1)->m_linesPerAction);
21621 resultobj = SWIG_From_int(static_cast< int >(result));
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629 PyObject *obj;
21630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21631 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21632 return SWIG_Py_Void();
21633 }
21634
21635 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21636 return SWIG_Python_InitShadowInstance(args);
21637 }
21638
21639 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj = 0;
21641 int arg1 = (int) 0 ;
21642 int arg2 = (int) 0 ;
21643 wxSetCursorEvent *result = 0 ;
21644 int val1 ;
21645 int ecode1 = 0 ;
21646 int val2 ;
21647 int ecode2 = 0 ;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char * kwnames[] = {
21651 (char *) "x",(char *) "y", NULL
21652 };
21653
21654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21655 if (obj0) {
21656 ecode1 = SWIG_AsVal_int(obj0, &val1);
21657 if (!SWIG_IsOK(ecode1)) {
21658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21659 }
21660 arg1 = static_cast< int >(val1);
21661 }
21662 if (obj1) {
21663 ecode2 = SWIG_AsVal_int(obj1, &val2);
21664 if (!SWIG_IsOK(ecode2)) {
21665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21666 }
21667 arg2 = static_cast< int >(val2);
21668 }
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21676 return resultobj;
21677 fail:
21678 return NULL;
21679 }
21680
21681
21682 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21683 PyObject *resultobj = 0;
21684 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21685 int result;
21686 void *argp1 = 0 ;
21687 int res1 = 0 ;
21688 PyObject *swig_obj[1] ;
21689
21690 if (!args) SWIG_fail;
21691 swig_obj[0] = args;
21692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21695 }
21696 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21700 wxPyEndAllowThreads(__tstate);
21701 if (PyErr_Occurred()) SWIG_fail;
21702 }
21703 resultobj = SWIG_From_int(static_cast< int >(result));
21704 return resultobj;
21705 fail:
21706 return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711 PyObject *resultobj = 0;
21712 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21713 int result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 PyObject *swig_obj[1] ;
21717
21718 if (!args) SWIG_fail;
21719 swig_obj[0] = args;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21723 }
21724 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 resultobj = SWIG_From_int(static_cast< int >(result));
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21739 PyObject *resultobj = 0;
21740 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21741 wxCursor *arg2 = 0 ;
21742 void *argp1 = 0 ;
21743 int res1 = 0 ;
21744 void *argp2 = 0 ;
21745 int res2 = 0 ;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char * kwnames[] = {
21749 (char *) "self",(char *) "cursor", NULL
21750 };
21751
21752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21754 if (!SWIG_IsOK(res1)) {
21755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21756 }
21757 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21759 if (!SWIG_IsOK(res2)) {
21760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21761 }
21762 if (!argp2) {
21763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21764 }
21765 arg2 = reinterpret_cast< wxCursor * >(argp2);
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 (arg1)->SetCursor((wxCursor const &)*arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_Py_Void();
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21782 wxCursor *result = 0 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 {
21797 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21798 result = (wxCursor *) &_result_ref;
21799 }
21800 wxPyEndAllowThreads(__tstate);
21801 if (PyErr_Occurred()) SWIG_fail;
21802 }
21803 {
21804 wxCursor* resultptr = new wxCursor(*result);
21805 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21806 }
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *resultobj = 0;
21815 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21816 bool result;
21817 void *argp1 = 0 ;
21818 int res1 = 0 ;
21819 PyObject *swig_obj[1] ;
21820
21821 if (!args) SWIG_fail;
21822 swig_obj[0] = args;
21823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21824 if (!SWIG_IsOK(res1)) {
21825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21826 }
21827 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 {
21835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21836 }
21837 return resultobj;
21838 fail:
21839 return NULL;
21840 }
21841
21842
21843 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21844 PyObject *obj;
21845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21846 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21847 return SWIG_Py_Void();
21848 }
21849
21850 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 return SWIG_Python_InitShadowInstance(args);
21852 }
21853
21854 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj = 0;
21856 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21857 wxKeyEvent *result = 0 ;
21858 int val1 ;
21859 int ecode1 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "eventType", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21866 if (obj0) {
21867 ecode1 = SWIG_AsVal_int(obj0, &val1);
21868 if (!SWIG_IsOK(ecode1)) {
21869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21870 }
21871 arg1 = static_cast< wxEventType >(val1);
21872 }
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21889 int result;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 PyObject *swig_obj[1] ;
21893
21894 if (!args) SWIG_fail;
21895 swig_obj[0] = args;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21899 }
21900 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 resultobj = SWIG_From_int(static_cast< int >(result));
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21915 PyObject *resultobj = 0;
21916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21917 bool result;
21918 void *argp1 = 0 ;
21919 int res1 = 0 ;
21920 PyObject *swig_obj[1] ;
21921
21922 if (!args) SWIG_fail;
21923 swig_obj[0] = args;
21924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21927 }
21928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21937 }
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945 PyObject *resultobj = 0;
21946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21947 bool result;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 PyObject *swig_obj[1] ;
21951
21952 if (!args) SWIG_fail;
21953 swig_obj[0] = args;
21954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21955 if (!SWIG_IsOK(res1)) {
21956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21957 }
21958 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21962 wxPyEndAllowThreads(__tstate);
21963 if (PyErr_Occurred()) SWIG_fail;
21964 }
21965 {
21966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21967 }
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21975 PyObject *resultobj = 0;
21976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21977 bool result;
21978 void *argp1 = 0 ;
21979 int res1 = 0 ;
21980 PyObject *swig_obj[1] ;
21981
21982 if (!args) SWIG_fail;
21983 swig_obj[0] = args;
21984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21985 if (!SWIG_IsOK(res1)) {
21986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21987 }
21988 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 {
21996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21997 }
21998 return resultobj;
21999 fail:
22000 return NULL;
22001 }
22002
22003
22004 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 PyObject *resultobj = 0;
22006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22007 bool result;
22008 void *argp1 = 0 ;
22009 int res1 = 0 ;
22010 PyObject *swig_obj[1] ;
22011
22012 if (!args) SWIG_fail;
22013 swig_obj[0] = args;
22014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22017 }
22018 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 return resultobj;
22029 fail:
22030 return NULL;
22031 }
22032
22033
22034 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22035 PyObject *resultobj = 0;
22036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22037 bool result;
22038 void *argp1 = 0 ;
22039 int res1 = 0 ;
22040 PyObject *swig_obj[1] ;
22041
22042 if (!args) SWIG_fail;
22043 swig_obj[0] = args;
22044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22045 if (!SWIG_IsOK(res1)) {
22046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22047 }
22048 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22049 {
22050 PyThreadState* __tstate = wxPyBeginAllowThreads();
22051 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22052 wxPyEndAllowThreads(__tstate);
22053 if (PyErr_Occurred()) SWIG_fail;
22054 }
22055 {
22056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22057 }
22058 return resultobj;
22059 fail:
22060 return NULL;
22061 }
22062
22063
22064 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22065 PyObject *resultobj = 0;
22066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22067 bool result;
22068 void *argp1 = 0 ;
22069 int res1 = 0 ;
22070 PyObject *swig_obj[1] ;
22071
22072 if (!args) SWIG_fail;
22073 swig_obj[0] = args;
22074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22075 if (!SWIG_IsOK(res1)) {
22076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22077 }
22078 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 {
22086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22087 }
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 PyObject *resultobj = 0;
22096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22097 int result;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 PyObject *swig_obj[1] ;
22101
22102 if (!args) SWIG_fail;
22103 swig_obj[0] = args;
22104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22107 }
22108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = SWIG_From_int(static_cast< int >(result));
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22123 PyObject *resultobj = 0;
22124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22125 int result;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject *swig_obj[1] ;
22129
22130 if (!args) SWIG_fail;
22131 swig_obj[0] = args;
22132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22133 if (!SWIG_IsOK(res1)) {
22134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22135 }
22136 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22137 {
22138 PyThreadState* __tstate = wxPyBeginAllowThreads();
22139 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 resultobj = SWIG_From_int(static_cast< int >(result));
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22151 PyObject *resultobj = 0;
22152 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22153 unsigned int result;
22154 void *argp1 = 0 ;
22155 int res1 = 0 ;
22156 PyObject *swig_obj[1] ;
22157
22158 if (!args) SWIG_fail;
22159 swig_obj[0] = args;
22160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22161 if (!SWIG_IsOK(res1)) {
22162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22163 }
22164 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22181 unsigned int result;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22191 }
22192 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22207 PyObject *resultobj = 0;
22208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22209 wxPoint result;
22210 void *argp1 = 0 ;
22211 int res1 = 0 ;
22212 PyObject *swig_obj[1] ;
22213
22214 if (!args) SWIG_fail;
22215 swig_obj[0] = args;
22216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22217 if (!SWIG_IsOK(res1)) {
22218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22219 }
22220 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (arg1)->GetPosition();
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 PyObject *resultobj = 0;
22236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22237 long *arg2 = (long *) 0 ;
22238 long *arg3 = (long *) 0 ;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 long temp2 ;
22242 int res2 = SWIG_TMPOBJ ;
22243 long temp3 ;
22244 int res3 = SWIG_TMPOBJ ;
22245 PyObject *swig_obj[1] ;
22246
22247 arg2 = &temp2;
22248 arg3 = &temp3;
22249 if (!args) SWIG_fail;
22250 swig_obj[0] = args;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22254 }
22255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 (arg1)->GetPosition(arg2,arg3);
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 resultobj = SWIG_Py_Void();
22263 if (SWIG_IsTmpObj(res2)) {
22264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22265 } else {
22266 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22268 }
22269 if (SWIG_IsTmpObj(res3)) {
22270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22271 } else {
22272 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22274 }
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 int result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22294 }
22295 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (int)((wxKeyEvent const *)arg1)->GetX();
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 resultobj = SWIG_From_int(static_cast< int >(result));
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 PyObject *resultobj = 0;
22311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22312 int result;
22313 void *argp1 = 0 ;
22314 int res1 = 0 ;
22315 PyObject *swig_obj[1] ;
22316
22317 if (!args) SWIG_fail;
22318 swig_obj[0] = args;
22319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22320 if (!SWIG_IsOK(res1)) {
22321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22322 }
22323 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (int)((wxKeyEvent const *)arg1)->GetY();
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 resultobj = SWIG_From_int(static_cast< int >(result));
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22340 int arg2 ;
22341 void *argp1 = 0 ;
22342 int res1 = 0 ;
22343 int val2 ;
22344 int ecode2 = 0 ;
22345 PyObject *swig_obj[2] ;
22346
22347 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22349 if (!SWIG_IsOK(res1)) {
22350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22351 }
22352 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22353 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22354 if (!SWIG_IsOK(ecode2)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22356 }
22357 arg2 = static_cast< int >(val2);
22358 if (arg1) (arg1)->m_x = arg2;
22359
22360 resultobj = SWIG_Py_Void();
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22368 PyObject *resultobj = 0;
22369 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22370 int result;
22371 void *argp1 = 0 ;
22372 int res1 = 0 ;
22373 PyObject *swig_obj[1] ;
22374
22375 if (!args) SWIG_fail;
22376 swig_obj[0] = args;
22377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22380 }
22381 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22382 result = (int) ((arg1)->m_x);
22383 resultobj = SWIG_From_int(static_cast< int >(result));
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *resultobj = 0;
22392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22393 int arg2 ;
22394 void *argp1 = 0 ;
22395 int res1 = 0 ;
22396 int val2 ;
22397 int ecode2 = 0 ;
22398 PyObject *swig_obj[2] ;
22399
22400 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22402 if (!SWIG_IsOK(res1)) {
22403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22404 }
22405 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22406 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22407 if (!SWIG_IsOK(ecode2)) {
22408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22409 }
22410 arg2 = static_cast< int >(val2);
22411 if (arg1) (arg1)->m_y = arg2;
22412
22413 resultobj = SWIG_Py_Void();
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22421 PyObject *resultobj = 0;
22422 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22423 int result;
22424 void *argp1 = 0 ;
22425 int res1 = 0 ;
22426 PyObject *swig_obj[1] ;
22427
22428 if (!args) SWIG_fail;
22429 swig_obj[0] = args;
22430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22431 if (!SWIG_IsOK(res1)) {
22432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22433 }
22434 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22435 result = (int) ((arg1)->m_y);
22436 resultobj = SWIG_From_int(static_cast< int >(result));
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22446 long arg2 ;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 long val2 ;
22450 int ecode2 = 0 ;
22451 PyObject *swig_obj[2] ;
22452
22453 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22455 if (!SWIG_IsOK(res1)) {
22456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22457 }
22458 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22459 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22460 if (!SWIG_IsOK(ecode2)) {
22461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22462 }
22463 arg2 = static_cast< long >(val2);
22464 if (arg1) (arg1)->m_keyCode = arg2;
22465
22466 resultobj = SWIG_Py_Void();
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 long result;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 PyObject *swig_obj[1] ;
22480
22481 if (!args) SWIG_fail;
22482 swig_obj[0] = args;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22488 result = (long) ((arg1)->m_keyCode);
22489 resultobj = SWIG_From_long(static_cast< long >(result));
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22499 bool arg2 ;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 bool val2 ;
22503 int ecode2 = 0 ;
22504 PyObject *swig_obj[2] ;
22505
22506 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22510 }
22511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22512 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22513 if (!SWIG_IsOK(ecode2)) {
22514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22515 }
22516 arg2 = static_cast< bool >(val2);
22517 if (arg1) (arg1)->m_controlDown = arg2;
22518
22519 resultobj = SWIG_Py_Void();
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 bool result;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 PyObject *swig_obj[1] ;
22533
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 result = (bool) ((arg1)->m_controlDown);
22542 {
22543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22544 }
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22552 PyObject *resultobj = 0;
22553 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22554 bool arg2 ;
22555 void *argp1 = 0 ;
22556 int res1 = 0 ;
22557 bool val2 ;
22558 int ecode2 = 0 ;
22559 PyObject *swig_obj[2] ;
22560
22561 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22563 if (!SWIG_IsOK(res1)) {
22564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22565 }
22566 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22567 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22568 if (!SWIG_IsOK(ecode2)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22570 }
22571 arg2 = static_cast< bool >(val2);
22572 if (arg1) (arg1)->m_shiftDown = arg2;
22573
22574 resultobj = SWIG_Py_Void();
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 PyObject *resultobj = 0;
22583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22584 bool result;
22585 void *argp1 = 0 ;
22586 int res1 = 0 ;
22587 PyObject *swig_obj[1] ;
22588
22589 if (!args) SWIG_fail;
22590 swig_obj[0] = args;
22591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22592 if (!SWIG_IsOK(res1)) {
22593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22594 }
22595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22596 result = (bool) ((arg1)->m_shiftDown);
22597 {
22598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22599 }
22600 return resultobj;
22601 fail:
22602 return NULL;
22603 }
22604
22605
22606 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 PyObject *resultobj = 0;
22608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22609 bool arg2 ;
22610 void *argp1 = 0 ;
22611 int res1 = 0 ;
22612 bool val2 ;
22613 int ecode2 = 0 ;
22614 PyObject *swig_obj[2] ;
22615
22616 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22620 }
22621 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22622 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22623 if (!SWIG_IsOK(ecode2)) {
22624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22625 }
22626 arg2 = static_cast< bool >(val2);
22627 if (arg1) (arg1)->m_altDown = arg2;
22628
22629 resultobj = SWIG_Py_Void();
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22637 PyObject *resultobj = 0;
22638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22639 bool result;
22640 void *argp1 = 0 ;
22641 int res1 = 0 ;
22642 PyObject *swig_obj[1] ;
22643
22644 if (!args) SWIG_fail;
22645 swig_obj[0] = args;
22646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22649 }
22650 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22651 result = (bool) ((arg1)->m_altDown);
22652 {
22653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22654 }
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22662 PyObject *resultobj = 0;
22663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22664 bool arg2 ;
22665 void *argp1 = 0 ;
22666 int res1 = 0 ;
22667 bool val2 ;
22668 int ecode2 = 0 ;
22669 PyObject *swig_obj[2] ;
22670
22671 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22673 if (!SWIG_IsOK(res1)) {
22674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22675 }
22676 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22677 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22678 if (!SWIG_IsOK(ecode2)) {
22679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22680 }
22681 arg2 = static_cast< bool >(val2);
22682 if (arg1) (arg1)->m_metaDown = arg2;
22683
22684 resultobj = SWIG_Py_Void();
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22692 PyObject *resultobj = 0;
22693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22694 bool result;
22695 void *argp1 = 0 ;
22696 int res1 = 0 ;
22697 PyObject *swig_obj[1] ;
22698
22699 if (!args) SWIG_fail;
22700 swig_obj[0] = args;
22701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22704 }
22705 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22706 result = (bool) ((arg1)->m_metaDown);
22707 {
22708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22709 }
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 PyObject *resultobj = 0;
22718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22719 bool arg2 ;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 bool val2 ;
22723 int ecode2 = 0 ;
22724 PyObject *swig_obj[2] ;
22725
22726 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22733 if (!SWIG_IsOK(ecode2)) {
22734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22735 }
22736 arg2 = static_cast< bool >(val2);
22737 if (arg1) (arg1)->m_scanCode = arg2;
22738
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22749 bool result;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 PyObject *swig_obj[1] ;
22753
22754 if (!args) SWIG_fail;
22755 swig_obj[0] = args;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22759 }
22760 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22761 result = (bool) ((arg1)->m_scanCode);
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 unsigned int arg2 ;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 unsigned int val2 ;
22778 int ecode2 = 0 ;
22779 PyObject *swig_obj[2] ;
22780
22781 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22783 if (!SWIG_IsOK(res1)) {
22784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22785 }
22786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22787 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22788 if (!SWIG_IsOK(ecode2)) {
22789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22790 }
22791 arg2 = static_cast< unsigned int >(val2);
22792 if (arg1) (arg1)->m_rawCode = arg2;
22793
22794 resultobj = SWIG_Py_Void();
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22804 unsigned int result;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 PyObject *swig_obj[1] ;
22808
22809 if (!args) SWIG_fail;
22810 swig_obj[0] = args;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22814 }
22815 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22816 result = (unsigned int) ((arg1)->m_rawCode);
22817 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22825 PyObject *resultobj = 0;
22826 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22827 unsigned int arg2 ;
22828 void *argp1 = 0 ;
22829 int res1 = 0 ;
22830 unsigned int val2 ;
22831 int ecode2 = 0 ;
22832 PyObject *swig_obj[2] ;
22833
22834 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22836 if (!SWIG_IsOK(res1)) {
22837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22838 }
22839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22840 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22841 if (!SWIG_IsOK(ecode2)) {
22842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22843 }
22844 arg2 = static_cast< unsigned int >(val2);
22845 if (arg1) (arg1)->m_rawFlags = arg2;
22846
22847 resultobj = SWIG_Py_Void();
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *resultobj = 0;
22856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22857 unsigned int result;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22867 }
22868 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22869 result = (unsigned int) ((arg1)->m_rawFlags);
22870 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22878 PyObject *obj;
22879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22880 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22881 return SWIG_Py_Void();
22882 }
22883
22884 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 return SWIG_Python_InitShadowInstance(args);
22886 }
22887
22888 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj = 0;
22890 wxSize const &arg1_defvalue = wxDefaultSize ;
22891 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22892 int arg2 = (int) 0 ;
22893 wxSizeEvent *result = 0 ;
22894 wxSize temp1 ;
22895 int val2 ;
22896 int ecode2 = 0 ;
22897 PyObject * obj0 = 0 ;
22898 PyObject * obj1 = 0 ;
22899 char * kwnames[] = {
22900 (char *) "sz",(char *) "winid", NULL
22901 };
22902
22903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22904 if (obj0) {
22905 {
22906 arg1 = &temp1;
22907 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22908 }
22909 }
22910 if (obj1) {
22911 ecode2 = SWIG_AsVal_int(obj1, &val2);
22912 if (!SWIG_IsOK(ecode2)) {
22913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22914 }
22915 arg2 = static_cast< int >(val2);
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22920 wxPyEndAllowThreads(__tstate);
22921 if (PyErr_Occurred()) SWIG_fail;
22922 }
22923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22924 return resultobj;
22925 fail:
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22933 wxSize result;
22934 void *argp1 = 0 ;
22935 int res1 = 0 ;
22936 PyObject *swig_obj[1] ;
22937
22938 if (!args) SWIG_fail;
22939 swig_obj[0] = args;
22940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22943 }
22944 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = ((wxSizeEvent const *)arg1)->GetSize();
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *resultobj = 0;
22960 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22961 wxRect result;
22962 void *argp1 = 0 ;
22963 int res1 = 0 ;
22964 PyObject *swig_obj[1] ;
22965
22966 if (!args) SWIG_fail;
22967 swig_obj[0] = args;
22968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 result = ((wxSizeEvent const *)arg1)->GetRect();
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj = 0;
22988 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22989 wxRect arg2 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 void *argp2 ;
22993 int res2 = 0 ;
22994 PyObject * obj0 = 0 ;
22995 PyObject * obj1 = 0 ;
22996 char * kwnames[] = {
22997 (char *) "self",(char *) "rect", NULL
22998 };
22999
23000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23004 }
23005 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23006 {
23007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23008 if (!SWIG_IsOK(res2)) {
23009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23010 }
23011 if (!argp2) {
23012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23013 } else {
23014 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23015 arg2 = *temp;
23016 if (SWIG_IsNewObj(res2)) delete temp;
23017 }
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 (arg1)->SetRect(arg2);
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_Py_Void();
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj = 0;
23034 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23035 wxSize arg2 ;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 void *argp2 ;
23039 int res2 = 0 ;
23040 PyObject * obj0 = 0 ;
23041 PyObject * obj1 = 0 ;
23042 char * kwnames[] = {
23043 (char *) "self",(char *) "size", NULL
23044 };
23045
23046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23050 }
23051 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23052 {
23053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23054 if (!SWIG_IsOK(res2)) {
23055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23056 }
23057 if (!argp2) {
23058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23059 } else {
23060 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23061 arg2 = *temp;
23062 if (SWIG_IsNewObj(res2)) delete temp;
23063 }
23064 }
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 wxSizeEvent_SetSize(arg1,arg2);
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 resultobj = SWIG_Py_Void();
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 PyObject *resultobj = 0;
23080 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23081 wxSize *arg2 = (wxSize *) 0 ;
23082 void *argp1 = 0 ;
23083 int res1 = 0 ;
23084 void *argp2 = 0 ;
23085 int res2 = 0 ;
23086 PyObject *swig_obj[2] ;
23087
23088 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23094 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23095 if (!SWIG_IsOK(res2)) {
23096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23097 }
23098 arg2 = reinterpret_cast< wxSize * >(argp2);
23099 if (arg1) (arg1)->m_size = *arg2;
23100
23101 resultobj = SWIG_Py_Void();
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23111 wxSize *result = 0 ;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23121 }
23122 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23123 result = (wxSize *)& ((arg1)->m_size);
23124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23132 PyObject *resultobj = 0;
23133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23134 wxRect *arg2 = (wxRect *) 0 ;
23135 void *argp1 = 0 ;
23136 int res1 = 0 ;
23137 void *argp2 = 0 ;
23138 int res2 = 0 ;
23139 PyObject *swig_obj[2] ;
23140
23141 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23143 if (!SWIG_IsOK(res1)) {
23144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23145 }
23146 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23147 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23148 if (!SWIG_IsOK(res2)) {
23149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23150 }
23151 arg2 = reinterpret_cast< wxRect * >(argp2);
23152 if (arg1) (arg1)->m_rect = *arg2;
23153
23154 resultobj = SWIG_Py_Void();
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23162 PyObject *resultobj = 0;
23163 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23164 wxRect *result = 0 ;
23165 void *argp1 = 0 ;
23166 int res1 = 0 ;
23167 PyObject *swig_obj[1] ;
23168
23169 if (!args) SWIG_fail;
23170 swig_obj[0] = args;
23171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23172 if (!SWIG_IsOK(res1)) {
23173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23174 }
23175 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23176 result = (wxRect *)& ((arg1)->m_rect);
23177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23185 PyObject *obj;
23186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23187 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23188 return SWIG_Py_Void();
23189 }
23190
23191 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23192 return SWIG_Python_InitShadowInstance(args);
23193 }
23194
23195 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23196 PyObject *resultobj = 0;
23197 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23198 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23199 int arg2 = (int) 0 ;
23200 wxMoveEvent *result = 0 ;
23201 wxPoint temp1 ;
23202 int val2 ;
23203 int ecode2 = 0 ;
23204 PyObject * obj0 = 0 ;
23205 PyObject * obj1 = 0 ;
23206 char * kwnames[] = {
23207 (char *) "pos",(char *) "winid", NULL
23208 };
23209
23210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23211 if (obj0) {
23212 {
23213 arg1 = &temp1;
23214 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23215 }
23216 }
23217 if (obj1) {
23218 ecode2 = SWIG_AsVal_int(obj1, &val2);
23219 if (!SWIG_IsOK(ecode2)) {
23220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23221 }
23222 arg2 = static_cast< int >(val2);
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23238 PyObject *resultobj = 0;
23239 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23240 wxPoint result;
23241 void *argp1 = 0 ;
23242 int res1 = 0 ;
23243 PyObject *swig_obj[1] ;
23244
23245 if (!args) SWIG_fail;
23246 swig_obj[0] = args;
23247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23248 if (!SWIG_IsOK(res1)) {
23249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23250 }
23251 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 result = ((wxMoveEvent const *)arg1)->GetPosition();
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23266 PyObject *resultobj = 0;
23267 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23268 wxRect result;
23269 void *argp1 = 0 ;
23270 int res1 = 0 ;
23271 PyObject *swig_obj[1] ;
23272
23273 if (!args) SWIG_fail;
23274 swig_obj[0] = args;
23275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23276 if (!SWIG_IsOK(res1)) {
23277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23278 }
23279 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23280 {
23281 PyThreadState* __tstate = wxPyBeginAllowThreads();
23282 result = ((wxMoveEvent const *)arg1)->GetRect();
23283 wxPyEndAllowThreads(__tstate);
23284 if (PyErr_Occurred()) SWIG_fail;
23285 }
23286 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23287 return resultobj;
23288 fail:
23289 return NULL;
23290 }
23291
23292
23293 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj = 0;
23295 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23296 wxRect *arg2 = 0 ;
23297 void *argp1 = 0 ;
23298 int res1 = 0 ;
23299 wxRect temp2 ;
23300 PyObject * obj0 = 0 ;
23301 PyObject * obj1 = 0 ;
23302 char * kwnames[] = {
23303 (char *) "self",(char *) "rect", NULL
23304 };
23305
23306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23308 if (!SWIG_IsOK(res1)) {
23309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23310 }
23311 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23312 {
23313 arg2 = &temp2;
23314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 (arg1)->SetRect((wxRect const &)*arg2);
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 resultobj = SWIG_Py_Void();
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23332 wxPoint *arg2 = 0 ;
23333 void *argp1 = 0 ;
23334 int res1 = 0 ;
23335 wxPoint temp2 ;
23336 PyObject * obj0 = 0 ;
23337 PyObject * obj1 = 0 ;
23338 char * kwnames[] = {
23339 (char *) "self",(char *) "pos", NULL
23340 };
23341
23342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23344 if (!SWIG_IsOK(res1)) {
23345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23346 }
23347 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23348 {
23349 arg2 = &temp2;
23350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 (arg1)->SetPosition((wxPoint const &)*arg2);
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 resultobj = SWIG_Py_Void();
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23366 PyObject *obj;
23367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23368 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23369 return SWIG_Py_Void();
23370 }
23371
23372 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23373 return SWIG_Python_InitShadowInstance(args);
23374 }
23375
23376 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23377 PyObject *resultobj = 0;
23378 int arg1 = (int) 0 ;
23379 wxPaintEvent *result = 0 ;
23380 int val1 ;
23381 int ecode1 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 char * kwnames[] = {
23384 (char *) "Id", NULL
23385 };
23386
23387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23388 if (obj0) {
23389 ecode1 = SWIG_AsVal_int(obj0, &val1);
23390 if (!SWIG_IsOK(ecode1)) {
23391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23392 }
23393 arg1 = static_cast< int >(val1);
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *obj;
23410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23411 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23412 return SWIG_Py_Void();
23413 }
23414
23415 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 return SWIG_Python_InitShadowInstance(args);
23417 }
23418
23419 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj = 0;
23421 int arg1 = (int) 0 ;
23422 wxNcPaintEvent *result = 0 ;
23423 int val1 ;
23424 int ecode1 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "winid", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23431 if (obj0) {
23432 ecode1 = SWIG_AsVal_int(obj0, &val1);
23433 if (!SWIG_IsOK(ecode1)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23435 }
23436 arg1 = static_cast< int >(val1);
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *obj;
23453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23454 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23455 return SWIG_Py_Void();
23456 }
23457
23458 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 return SWIG_Python_InitShadowInstance(args);
23460 }
23461
23462 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 int arg1 = (int) 0 ;
23465 wxDC *arg2 = (wxDC *) NULL ;
23466 wxEraseEvent *result = 0 ;
23467 int val1 ;
23468 int ecode1 = 0 ;
23469 void *argp2 = 0 ;
23470 int res2 = 0 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "Id",(char *) "dc", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23478 if (obj0) {
23479 ecode1 = SWIG_AsVal_int(obj0, &val1);
23480 if (!SWIG_IsOK(ecode1)) {
23481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23482 }
23483 arg1 = static_cast< int >(val1);
23484 }
23485 if (obj1) {
23486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23487 if (!SWIG_IsOK(res2)) {
23488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23489 }
23490 arg2 = reinterpret_cast< wxDC * >(argp2);
23491 }
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23495 wxPyEndAllowThreads(__tstate);
23496 if (PyErr_Occurred()) SWIG_fail;
23497 }
23498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23499 return resultobj;
23500 fail:
23501 return NULL;
23502 }
23503
23504
23505 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23506 PyObject *resultobj = 0;
23507 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23508 wxDC *result = 0 ;
23509 void *argp1 = 0 ;
23510 int res1 = 0 ;
23511 PyObject *swig_obj[1] ;
23512
23513 if (!args) SWIG_fail;
23514 swig_obj[0] = args;
23515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23516 if (!SWIG_IsOK(res1)) {
23517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23518 }
23519 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = wxPyMake_wxObject(result, (bool)0);
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23536 PyObject *obj;
23537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23538 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23539 return SWIG_Py_Void();
23540 }
23541
23542 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23543 return SWIG_Python_InitShadowInstance(args);
23544 }
23545
23546 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = 0;
23548 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23549 int arg2 = (int) 0 ;
23550 wxFocusEvent *result = 0 ;
23551 int val1 ;
23552 int ecode1 = 0 ;
23553 int val2 ;
23554 int ecode2 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 PyObject * obj1 = 0 ;
23557 char * kwnames[] = {
23558 (char *) "type",(char *) "winid", NULL
23559 };
23560
23561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23562 if (obj0) {
23563 ecode1 = SWIG_AsVal_int(obj0, &val1);
23564 if (!SWIG_IsOK(ecode1)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23566 }
23567 arg1 = static_cast< wxEventType >(val1);
23568 }
23569 if (obj1) {
23570 ecode2 = SWIG_AsVal_int(obj1, &val2);
23571 if (!SWIG_IsOK(ecode2)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23573 }
23574 arg2 = static_cast< int >(val2);
23575 }
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23590 PyObject *resultobj = 0;
23591 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23592 wxWindow *result = 0 ;
23593 void *argp1 = 0 ;
23594 int res1 = 0 ;
23595 PyObject *swig_obj[1] ;
23596
23597 if (!args) SWIG_fail;
23598 swig_obj[0] = args;
23599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23600 if (!SWIG_IsOK(res1)) {
23601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23602 }
23603 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 resultobj = wxPyMake_wxObject(result, (bool)0);
23612 }
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj = 0;
23621 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23622 wxWindow *arg2 = (wxWindow *) 0 ;
23623 void *argp1 = 0 ;
23624 int res1 = 0 ;
23625 void *argp2 = 0 ;
23626 int res2 = 0 ;
23627 PyObject * obj0 = 0 ;
23628 PyObject * obj1 = 0 ;
23629 char * kwnames[] = {
23630 (char *) "self",(char *) "win", NULL
23631 };
23632
23633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23635 if (!SWIG_IsOK(res1)) {
23636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23637 }
23638 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23640 if (!SWIG_IsOK(res2)) {
23641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23642 }
23643 arg2 = reinterpret_cast< wxWindow * >(argp2);
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 (arg1)->SetWindow(arg2);
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 resultobj = SWIG_Py_Void();
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23658 PyObject *obj;
23659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23660 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23661 return SWIG_Py_Void();
23662 }
23663
23664 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23665 return SWIG_Python_InitShadowInstance(args);
23666 }
23667
23668 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj = 0;
23670 wxWindow *arg1 = (wxWindow *) NULL ;
23671 wxChildFocusEvent *result = 0 ;
23672 void *argp1 = 0 ;
23673 int res1 = 0 ;
23674 PyObject * obj0 = 0 ;
23675 char * kwnames[] = {
23676 (char *) "win", NULL
23677 };
23678
23679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23680 if (obj0) {
23681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23682 if (!SWIG_IsOK(res1)) {
23683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23684 }
23685 arg1 = reinterpret_cast< wxWindow * >(argp1);
23686 }
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23694 return resultobj;
23695 fail:
23696 return NULL;
23697 }
23698
23699
23700 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23701 PyObject *resultobj = 0;
23702 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23703 wxWindow *result = 0 ;
23704 void *argp1 = 0 ;
23705 int res1 = 0 ;
23706 PyObject *swig_obj[1] ;
23707
23708 if (!args) SWIG_fail;
23709 swig_obj[0] = args;
23710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23711 if (!SWIG_IsOK(res1)) {
23712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23713 }
23714 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23715 {
23716 PyThreadState* __tstate = wxPyBeginAllowThreads();
23717 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23718 wxPyEndAllowThreads(__tstate);
23719 if (PyErr_Occurred()) SWIG_fail;
23720 }
23721 {
23722 resultobj = wxPyMake_wxObject(result, (bool)0);
23723 }
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23731 PyObject *obj;
23732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23733 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23734 return SWIG_Py_Void();
23735 }
23736
23737 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23738 return SWIG_Python_InitShadowInstance(args);
23739 }
23740
23741 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj = 0;
23743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23744 bool arg2 = (bool) true ;
23745 int arg3 = (int) 0 ;
23746 wxActivateEvent *result = 0 ;
23747 int val1 ;
23748 int ecode1 = 0 ;
23749 bool val2 ;
23750 int ecode2 = 0 ;
23751 int val3 ;
23752 int ecode3 = 0 ;
23753 PyObject * obj0 = 0 ;
23754 PyObject * obj1 = 0 ;
23755 PyObject * obj2 = 0 ;
23756 char * kwnames[] = {
23757 (char *) "type",(char *) "active",(char *) "Id", NULL
23758 };
23759
23760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23761 if (obj0) {
23762 ecode1 = SWIG_AsVal_int(obj0, &val1);
23763 if (!SWIG_IsOK(ecode1)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23765 }
23766 arg1 = static_cast< wxEventType >(val1);
23767 }
23768 if (obj1) {
23769 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23770 if (!SWIG_IsOK(ecode2)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23772 }
23773 arg2 = static_cast< bool >(val2);
23774 }
23775 if (obj2) {
23776 ecode3 = SWIG_AsVal_int(obj2, &val3);
23777 if (!SWIG_IsOK(ecode3)) {
23778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23779 }
23780 arg3 = static_cast< int >(val3);
23781 }
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23798 bool result;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 PyObject *swig_obj[1] ;
23802
23803 if (!args) SWIG_fail;
23804 swig_obj[0] = args;
23805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23808 }
23809 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *obj;
23827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23828 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23829 return SWIG_Py_Void();
23830 }
23831
23832 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23833 return SWIG_Python_InitShadowInstance(args);
23834 }
23835
23836 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj = 0;
23838 int arg1 = (int) 0 ;
23839 wxInitDialogEvent *result = 0 ;
23840 int val1 ;
23841 int ecode1 = 0 ;
23842 PyObject * obj0 = 0 ;
23843 char * kwnames[] = {
23844 (char *) "Id", NULL
23845 };
23846
23847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23848 if (obj0) {
23849 ecode1 = SWIG_AsVal_int(obj0, &val1);
23850 if (!SWIG_IsOK(ecode1)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23852 }
23853 arg1 = static_cast< int >(val1);
23854 }
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23882 int arg2 = (int) 0 ;
23883 wxMenu *arg3 = (wxMenu *) NULL ;
23884 wxMenuEvent *result = 0 ;
23885 int val1 ;
23886 int ecode1 = 0 ;
23887 int val2 ;
23888 int ecode2 = 0 ;
23889 void *argp3 = 0 ;
23890 int res3 = 0 ;
23891 PyObject * obj0 = 0 ;
23892 PyObject * obj1 = 0 ;
23893 PyObject * obj2 = 0 ;
23894 char * kwnames[] = {
23895 (char *) "type",(char *) "winid",(char *) "menu", NULL
23896 };
23897
23898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23899 if (obj0) {
23900 ecode1 = SWIG_AsVal_int(obj0, &val1);
23901 if (!SWIG_IsOK(ecode1)) {
23902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23903 }
23904 arg1 = static_cast< wxEventType >(val1);
23905 }
23906 if (obj1) {
23907 ecode2 = SWIG_AsVal_int(obj1, &val2);
23908 if (!SWIG_IsOK(ecode2)) {
23909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23910 }
23911 arg2 = static_cast< int >(val2);
23912 }
23913 if (obj2) {
23914 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23915 if (!SWIG_IsOK(res3)) {
23916 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23917 }
23918 arg3 = reinterpret_cast< wxMenu * >(argp3);
23919 }
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23934 PyObject *resultobj = 0;
23935 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23936 int result;
23937 void *argp1 = 0 ;
23938 int res1 = 0 ;
23939 PyObject *swig_obj[1] ;
23940
23941 if (!args) SWIG_fail;
23942 swig_obj[0] = args;
23943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23944 if (!SWIG_IsOK(res1)) {
23945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23946 }
23947 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_From_int(static_cast< int >(result));
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *resultobj = 0;
23963 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23964 bool result;
23965 void *argp1 = 0 ;
23966 int res1 = 0 ;
23967 PyObject *swig_obj[1] ;
23968
23969 if (!args) SWIG_fail;
23970 swig_obj[0] = args;
23971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23972 if (!SWIG_IsOK(res1)) {
23973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23974 }
23975 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 {
23983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23984 }
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23994 wxMenu *result = 0 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24004 }
24005 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 resultobj = wxPyMake_wxObject(result, (bool)0);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *obj;
24023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24024 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24025 return SWIG_Py_Void();
24026 }
24027
24028 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24029 return SWIG_Python_InitShadowInstance(args);
24030 }
24031
24032 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj = 0;
24034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24035 int arg2 = (int) 0 ;
24036 wxCloseEvent *result = 0 ;
24037 int val1 ;
24038 int ecode1 = 0 ;
24039 int val2 ;
24040 int ecode2 = 0 ;
24041 PyObject * obj0 = 0 ;
24042 PyObject * obj1 = 0 ;
24043 char * kwnames[] = {
24044 (char *) "type",(char *) "winid", NULL
24045 };
24046
24047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24048 if (obj0) {
24049 ecode1 = SWIG_AsVal_int(obj0, &val1);
24050 if (!SWIG_IsOK(ecode1)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24052 }
24053 arg1 = static_cast< wxEventType >(val1);
24054 }
24055 if (obj1) {
24056 ecode2 = SWIG_AsVal_int(obj1, &val2);
24057 if (!SWIG_IsOK(ecode2)) {
24058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24059 }
24060 arg2 = static_cast< int >(val2);
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj = 0;
24077 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24078 bool arg2 ;
24079 void *argp1 = 0 ;
24080 int res1 = 0 ;
24081 bool val2 ;
24082 int ecode2 = 0 ;
24083 PyObject * obj0 = 0 ;
24084 PyObject * obj1 = 0 ;
24085 char * kwnames[] = {
24086 (char *) "self",(char *) "logOff", NULL
24087 };
24088
24089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24091 if (!SWIG_IsOK(res1)) {
24092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24093 }
24094 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24096 if (!SWIG_IsOK(ecode2)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24098 }
24099 arg2 = static_cast< bool >(val2);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 (arg1)->SetLoggingOff(arg2);
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_Py_Void();
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24116 bool result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24126 }
24127 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj = 0;
24145 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24146 bool arg2 = (bool) true ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 bool val2 ;
24150 int ecode2 = 0 ;
24151 PyObject * obj0 = 0 ;
24152 PyObject * obj1 = 0 ;
24153 char * kwnames[] = {
24154 (char *) "self",(char *) "veto", NULL
24155 };
24156
24157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24159 if (!SWIG_IsOK(res1)) {
24160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24161 }
24162 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24163 if (obj1) {
24164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24165 if (!SWIG_IsOK(ecode2)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24167 }
24168 arg2 = static_cast< bool >(val2);
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 (arg1)->Veto(arg2);
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 resultobj = SWIG_Py_Void();
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24184 PyObject *resultobj = 0;
24185 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24186 bool result;
24187 void *argp1 = 0 ;
24188 int res1 = 0 ;
24189 PyObject *swig_obj[1] ;
24190
24191 if (!args) SWIG_fail;
24192 swig_obj[0] = args;
24193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24196 }
24197 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj = 0;
24215 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24216 bool arg2 ;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 bool val2 ;
24220 int ecode2 = 0 ;
24221 PyObject * obj0 = 0 ;
24222 PyObject * obj1 = 0 ;
24223 char * kwnames[] = {
24224 (char *) "self",(char *) "canVeto", NULL
24225 };
24226
24227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24229 if (!SWIG_IsOK(res1)) {
24230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24231 }
24232 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24234 if (!SWIG_IsOK(ecode2)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24236 }
24237 arg2 = static_cast< bool >(val2);
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 (arg1)->SetCanVeto(arg2);
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_Py_Void();
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24252 PyObject *resultobj = 0;
24253 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24254 bool result;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 PyObject *swig_obj[1] ;
24258
24259 if (!args) SWIG_fail;
24260 swig_obj[0] = args;
24261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24264 }
24265 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 {
24273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24274 }
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *obj;
24283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24284 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24285 return SWIG_Py_Void();
24286 }
24287
24288 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24289 return SWIG_Python_InitShadowInstance(args);
24290 }
24291
24292 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj = 0;
24294 int arg1 = (int) 0 ;
24295 bool arg2 = (bool) false ;
24296 wxShowEvent *result = 0 ;
24297 int val1 ;
24298 int ecode1 = 0 ;
24299 bool val2 ;
24300 int ecode2 = 0 ;
24301 PyObject * obj0 = 0 ;
24302 PyObject * obj1 = 0 ;
24303 char * kwnames[] = {
24304 (char *) "winid",(char *) "show", NULL
24305 };
24306
24307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24308 if (obj0) {
24309 ecode1 = SWIG_AsVal_int(obj0, &val1);
24310 if (!SWIG_IsOK(ecode1)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24312 }
24313 arg1 = static_cast< int >(val1);
24314 }
24315 if (obj1) {
24316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24317 if (!SWIG_IsOK(ecode2)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24319 }
24320 arg2 = static_cast< bool >(val2);
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24338 bool arg2 ;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 bool val2 ;
24342 int ecode2 = 0 ;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "self",(char *) "show", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24351 if (!SWIG_IsOK(res1)) {
24352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24353 }
24354 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24356 if (!SWIG_IsOK(ecode2)) {
24357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24358 }
24359 arg2 = static_cast< bool >(val2);
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 (arg1)->SetShow(arg2);
24363 wxPyEndAllowThreads(__tstate);
24364 if (PyErr_Occurred()) SWIG_fail;
24365 }
24366 resultobj = SWIG_Py_Void();
24367 return resultobj;
24368 fail:
24369 return NULL;
24370 }
24371
24372
24373 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24374 PyObject *resultobj = 0;
24375 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24376 bool result;
24377 void *argp1 = 0 ;
24378 int res1 = 0 ;
24379 PyObject *swig_obj[1] ;
24380
24381 if (!args) SWIG_fail;
24382 swig_obj[0] = args;
24383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24384 if (!SWIG_IsOK(res1)) {
24385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24386 }
24387 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24391 wxPyEndAllowThreads(__tstate);
24392 if (PyErr_Occurred()) SWIG_fail;
24393 }
24394 {
24395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24396 }
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *obj;
24405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24406 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24407 return SWIG_Py_Void();
24408 }
24409
24410 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24411 return SWIG_Python_InitShadowInstance(args);
24412 }
24413
24414 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24415 PyObject *resultobj = 0;
24416 int arg1 = (int) 0 ;
24417 bool arg2 = (bool) true ;
24418 wxIconizeEvent *result = 0 ;
24419 int val1 ;
24420 int ecode1 = 0 ;
24421 bool val2 ;
24422 int ecode2 = 0 ;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 char * kwnames[] = {
24426 (char *) "id",(char *) "iconized", NULL
24427 };
24428
24429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24430 if (obj0) {
24431 ecode1 = SWIG_AsVal_int(obj0, &val1);
24432 if (!SWIG_IsOK(ecode1)) {
24433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24434 }
24435 arg1 = static_cast< int >(val1);
24436 }
24437 if (obj1) {
24438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24439 if (!SWIG_IsOK(ecode2)) {
24440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24441 }
24442 arg2 = static_cast< bool >(val2);
24443 }
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24458 PyObject *resultobj = 0;
24459 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24460 bool result;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 PyObject *swig_obj[1] ;
24464
24465 if (!args) SWIG_fail;
24466 swig_obj[0] = args;
24467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24468 if (!SWIG_IsOK(res1)) {
24469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24470 }
24471 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24472 {
24473 PyThreadState* __tstate = wxPyBeginAllowThreads();
24474 result = (bool)(arg1)->Iconized();
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 {
24479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24480 }
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24488 PyObject *obj;
24489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24490 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24491 return SWIG_Py_Void();
24492 }
24493
24494 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24495 return SWIG_Python_InitShadowInstance(args);
24496 }
24497
24498 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj = 0;
24500 int arg1 = (int) 0 ;
24501 wxMaximizeEvent *result = 0 ;
24502 int val1 ;
24503 int ecode1 = 0 ;
24504 PyObject * obj0 = 0 ;
24505 char * kwnames[] = {
24506 (char *) "id", NULL
24507 };
24508
24509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24510 if (obj0) {
24511 ecode1 = SWIG_AsVal_int(obj0, &val1);
24512 if (!SWIG_IsOK(ecode1)) {
24513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24514 }
24515 arg1 = static_cast< int >(val1);
24516 }
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24531 PyObject *obj;
24532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24533 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24534 return SWIG_Py_Void();
24535 }
24536
24537 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24538 return SWIG_Python_InitShadowInstance(args);
24539 }
24540
24541 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 PyObject *resultobj = 0;
24543 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24544 wxPoint result;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 PyObject *swig_obj[1] ;
24548
24549 if (!args) SWIG_fail;
24550 swig_obj[0] = args;
24551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24552 if (!SWIG_IsOK(res1)) {
24553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24554 }
24555 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = (arg1)->GetPosition();
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24570 PyObject *resultobj = 0;
24571 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24572 int result;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 PyObject *swig_obj[1] ;
24576
24577 if (!args) SWIG_fail;
24578 swig_obj[0] = args;
24579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24580 if (!SWIG_IsOK(res1)) {
24581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24582 }
24583 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24584 {
24585 PyThreadState* __tstate = wxPyBeginAllowThreads();
24586 result = (int)(arg1)->GetNumberOfFiles();
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_From_int(static_cast< int >(result));
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 PyObject *resultobj = 0;
24599 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24600 PyObject *result = 0 ;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 PyObject *swig_obj[1] ;
24604
24605 if (!args) SWIG_fail;
24606 swig_obj[0] = args;
24607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24608 if (!SWIG_IsOK(res1)) {
24609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24610 }
24611 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 resultobj = result;
24619 return resultobj;
24620 fail:
24621 return NULL;
24622 }
24623
24624
24625 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24626 PyObject *obj;
24627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24628 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24629 return SWIG_Py_Void();
24630 }
24631
24632 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24633 PyObject *resultobj = 0;
24634 int arg1 = (int) 0 ;
24635 wxUpdateUIEvent *result = 0 ;
24636 int val1 ;
24637 int ecode1 = 0 ;
24638 PyObject * obj0 = 0 ;
24639 char * kwnames[] = {
24640 (char *) "commandId", NULL
24641 };
24642
24643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24644 if (obj0) {
24645 ecode1 = SWIG_AsVal_int(obj0, &val1);
24646 if (!SWIG_IsOK(ecode1)) {
24647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24648 }
24649 arg1 = static_cast< int >(val1);
24650 }
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *resultobj = 0;
24666 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24667 bool result;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 PyObject *swig_obj[1] ;
24671
24672 if (!args) SWIG_fail;
24673 swig_obj[0] = args;
24674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24677 }
24678 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 {
24686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *resultobj = 0;
24696 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24697 bool result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 PyObject *swig_obj[1] ;
24701
24702 if (!args) SWIG_fail;
24703 swig_obj[0] = args;
24704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24707 }
24708 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24757 wxString result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 #if wxUSE_UNICODE
24777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24778 #else
24779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24780 #endif
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24789 PyObject *resultobj = 0;
24790 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24791 bool result;
24792 void *argp1 = 0 ;
24793 int res1 = 0 ;
24794 PyObject *swig_obj[1] ;
24795
24796 if (!args) SWIG_fail;
24797 swig_obj[0] = args;
24798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24799 if (!SWIG_IsOK(res1)) {
24800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24801 }
24802 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24819 PyObject *resultobj = 0;
24820 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24821 bool result;
24822 void *argp1 = 0 ;
24823 int res1 = 0 ;
24824 PyObject *swig_obj[1] ;
24825
24826 if (!args) SWIG_fail;
24827 swig_obj[0] = args;
24828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24831 }
24832 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24849 PyObject *resultobj = 0;
24850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24851 bool result;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 PyObject *swig_obj[1] ;
24855
24856 if (!args) SWIG_fail;
24857 swig_obj[0] = args;
24858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24859 if (!SWIG_IsOK(res1)) {
24860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24861 }
24862 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *resultobj = 0;
24880 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24881 bool result;
24882 void *argp1 = 0 ;
24883 int res1 = 0 ;
24884 PyObject *swig_obj[1] ;
24885
24886 if (!args) SWIG_fail;
24887 swig_obj[0] = args;
24888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24889 if (!SWIG_IsOK(res1)) {
24890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24891 }
24892 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24893 {
24894 PyThreadState* __tstate = wxPyBeginAllowThreads();
24895 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 {
24900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj = 0;
24910 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24911 bool arg2 ;
24912 void *argp1 = 0 ;
24913 int res1 = 0 ;
24914 bool val2 ;
24915 int ecode2 = 0 ;
24916 PyObject * obj0 = 0 ;
24917 PyObject * obj1 = 0 ;
24918 char * kwnames[] = {
24919 (char *) "self",(char *) "check", NULL
24920 };
24921
24922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24924 if (!SWIG_IsOK(res1)) {
24925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24926 }
24927 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24929 if (!SWIG_IsOK(ecode2)) {
24930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24931 }
24932 arg2 = static_cast< bool >(val2);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 (arg1)->Check(arg2);
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_Py_Void();
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj = 0;
24948 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24949 bool arg2 ;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 bool val2 ;
24953 int ecode2 = 0 ;
24954 PyObject * obj0 = 0 ;
24955 PyObject * obj1 = 0 ;
24956 char * kwnames[] = {
24957 (char *) "self",(char *) "enable", NULL
24958 };
24959
24960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24964 }
24965 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24967 if (!SWIG_IsOK(ecode2)) {
24968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24969 }
24970 arg2 = static_cast< bool >(val2);
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 (arg1)->Enable(arg2);
24974 wxPyEndAllowThreads(__tstate);
24975 if (PyErr_Occurred()) SWIG_fail;
24976 }
24977 resultobj = SWIG_Py_Void();
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj = 0;
24986 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24987 bool arg2 ;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 bool val2 ;
24991 int ecode2 = 0 ;
24992 PyObject * obj0 = 0 ;
24993 PyObject * obj1 = 0 ;
24994 char * kwnames[] = {
24995 (char *) "self",(char *) "show", NULL
24996 };
24997
24998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25002 }
25003 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25005 if (!SWIG_IsOK(ecode2)) {
25006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25007 }
25008 arg2 = static_cast< bool >(val2);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 (arg1)->Show(arg2);
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 resultobj = SWIG_Py_Void();
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25025 wxString *arg2 = 0 ;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 bool temp2 = false ;
25029 PyObject * obj0 = 0 ;
25030 PyObject * obj1 = 0 ;
25031 char * kwnames[] = {
25032 (char *) "self",(char *) "text", NULL
25033 };
25034
25035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25039 }
25040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25041 {
25042 arg2 = wxString_in_helper(obj1);
25043 if (arg2 == NULL) SWIG_fail;
25044 temp2 = true;
25045 }
25046 {
25047 PyThreadState* __tstate = wxPyBeginAllowThreads();
25048 (arg1)->SetText((wxString const &)*arg2);
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 resultobj = SWIG_Py_Void();
25053 {
25054 if (temp2)
25055 delete arg2;
25056 }
25057 return resultobj;
25058 fail:
25059 {
25060 if (temp2)
25061 delete arg2;
25062 }
25063 return NULL;
25064 }
25065
25066
25067 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25068 PyObject *resultobj = 0;
25069 long arg1 ;
25070 long val1 ;
25071 int ecode1 = 0 ;
25072 PyObject * obj0 = 0 ;
25073 char * kwnames[] = {
25074 (char *) "updateInterval", NULL
25075 };
25076
25077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25078 ecode1 = SWIG_AsVal_long(obj0, &val1);
25079 if (!SWIG_IsOK(ecode1)) {
25080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25081 }
25082 arg1 = static_cast< long >(val1);
25083 {
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 wxUpdateUIEvent::SetUpdateInterval(arg1);
25086 wxPyEndAllowThreads(__tstate);
25087 if (PyErr_Occurred()) SWIG_fail;
25088 }
25089 resultobj = SWIG_Py_Void();
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25097 PyObject *resultobj = 0;
25098 long result;
25099
25100 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 resultobj = SWIG_From_long(static_cast< long >(result));
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = 0;
25116 wxWindow *arg1 = (wxWindow *) 0 ;
25117 bool result;
25118 void *argp1 = 0 ;
25119 int res1 = 0 ;
25120 PyObject * obj0 = 0 ;
25121 char * kwnames[] = {
25122 (char *) "win", NULL
25123 };
25124
25125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25127 if (!SWIG_IsOK(res1)) {
25128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25129 }
25130 arg1 = reinterpret_cast< wxWindow * >(argp1);
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25147 PyObject *resultobj = 0;
25148
25149 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 wxUpdateUIEvent::ResetUpdateTime();
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 resultobj = SWIG_Py_Void();
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj = 0;
25165 wxUpdateUIMode arg1 ;
25166 int val1 ;
25167 int ecode1 = 0 ;
25168 PyObject * obj0 = 0 ;
25169 char * kwnames[] = {
25170 (char *) "mode", NULL
25171 };
25172
25173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25174 ecode1 = SWIG_AsVal_int(obj0, &val1);
25175 if (!SWIG_IsOK(ecode1)) {
25176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25177 }
25178 arg1 = static_cast< wxUpdateUIMode >(val1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 wxUpdateUIEvent::SetMode(arg1);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_Py_Void();
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 wxUpdateUIMode result;
25195
25196 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_From_int(static_cast< int >(result));
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25211 PyObject *obj;
25212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25213 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25214 return SWIG_Py_Void();
25215 }
25216
25217 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218 return SWIG_Python_InitShadowInstance(args);
25219 }
25220
25221 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25222 PyObject *resultobj = 0;
25223 wxSysColourChangedEvent *result = 0 ;
25224
25225 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25240 PyObject *obj;
25241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25242 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25243 return SWIG_Py_Void();
25244 }
25245
25246 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 return SWIG_Python_InitShadowInstance(args);
25248 }
25249
25250 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 int arg1 = (int) 0 ;
25253 wxWindow *arg2 = (wxWindow *) NULL ;
25254 wxMouseCaptureChangedEvent *result = 0 ;
25255 int val1 ;
25256 int ecode1 = 0 ;
25257 void *argp2 = 0 ;
25258 int res2 = 0 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "winid",(char *) "gainedCapture", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25266 if (obj0) {
25267 ecode1 = SWIG_AsVal_int(obj0, &val1);
25268 if (!SWIG_IsOK(ecode1)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25270 }
25271 arg1 = static_cast< int >(val1);
25272 }
25273 if (obj1) {
25274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25275 if (!SWIG_IsOK(res2)) {
25276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25277 }
25278 arg2 = reinterpret_cast< wxWindow * >(argp2);
25279 }
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25294 PyObject *resultobj = 0;
25295 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25296 wxWindow *result = 0 ;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 PyObject *swig_obj[1] ;
25300
25301 if (!args) SWIG_fail;
25302 swig_obj[0] = args;
25303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25304 if (!SWIG_IsOK(res1)) {
25305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25306 }
25307 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 {
25315 resultobj = wxPyMake_wxObject(result, (bool)0);
25316 }
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *obj;
25325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25326 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25327 return SWIG_Py_Void();
25328 }
25329
25330 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25331 return SWIG_Python_InitShadowInstance(args);
25332 }
25333
25334 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 PyObject *resultobj = 0;
25336 wxDisplayChangedEvent *result = 0 ;
25337
25338 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25346 return resultobj;
25347 fail:
25348 return NULL;
25349 }
25350
25351
25352 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25353 PyObject *obj;
25354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25355 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25356 return SWIG_Py_Void();
25357 }
25358
25359 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25360 return SWIG_Python_InitShadowInstance(args);
25361 }
25362
25363 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj = 0;
25365 int arg1 = (int) 0 ;
25366 wxPaletteChangedEvent *result = 0 ;
25367 int val1 ;
25368 int ecode1 = 0 ;
25369 PyObject * obj0 = 0 ;
25370 char * kwnames[] = {
25371 (char *) "id", NULL
25372 };
25373
25374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25375 if (obj0) {
25376 ecode1 = SWIG_AsVal_int(obj0, &val1);
25377 if (!SWIG_IsOK(ecode1)) {
25378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25379 }
25380 arg1 = static_cast< int >(val1);
25381 }
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25396 PyObject *resultobj = 0;
25397 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25398 wxWindow *arg2 = (wxWindow *) 0 ;
25399 void *argp1 = 0 ;
25400 int res1 = 0 ;
25401 void *argp2 = 0 ;
25402 int res2 = 0 ;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 char * kwnames[] = {
25406 (char *) "self",(char *) "win", NULL
25407 };
25408
25409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25411 if (!SWIG_IsOK(res1)) {
25412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25413 }
25414 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25416 if (!SWIG_IsOK(res2)) {
25417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25418 }
25419 arg2 = reinterpret_cast< wxWindow * >(argp2);
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 (arg1)->SetChangedWindow(arg2);
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 resultobj = SWIG_Py_Void();
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 PyObject *resultobj = 0;
25435 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25436 wxWindow *result = 0 ;
25437 void *argp1 = 0 ;
25438 int res1 = 0 ;
25439 PyObject *swig_obj[1] ;
25440
25441 if (!args) SWIG_fail;
25442 swig_obj[0] = args;
25443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25444 if (!SWIG_IsOK(res1)) {
25445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25446 }
25447 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = (wxWindow *)(arg1)->GetChangedWindow();
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 {
25455 resultobj = wxPyMake_wxObject(result, (bool)0);
25456 }
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25464 PyObject *obj;
25465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25466 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25467 return SWIG_Py_Void();
25468 }
25469
25470 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25471 return SWIG_Python_InitShadowInstance(args);
25472 }
25473
25474 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj = 0;
25476 int arg1 = (int) 0 ;
25477 wxQueryNewPaletteEvent *result = 0 ;
25478 int val1 ;
25479 int ecode1 = 0 ;
25480 PyObject * obj0 = 0 ;
25481 char * kwnames[] = {
25482 (char *) "winid", NULL
25483 };
25484
25485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25486 if (obj0) {
25487 ecode1 = SWIG_AsVal_int(obj0, &val1);
25488 if (!SWIG_IsOK(ecode1)) {
25489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25490 }
25491 arg1 = static_cast< int >(val1);
25492 }
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25496 wxPyEndAllowThreads(__tstate);
25497 if (PyErr_Occurred()) SWIG_fail;
25498 }
25499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25507 PyObject *resultobj = 0;
25508 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25509 bool arg2 ;
25510 void *argp1 = 0 ;
25511 int res1 = 0 ;
25512 bool val2 ;
25513 int ecode2 = 0 ;
25514 PyObject * obj0 = 0 ;
25515 PyObject * obj1 = 0 ;
25516 char * kwnames[] = {
25517 (char *) "self",(char *) "realized", NULL
25518 };
25519
25520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25524 }
25525 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25527 if (!SWIG_IsOK(ecode2)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25529 }
25530 arg2 = static_cast< bool >(val2);
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 (arg1)->SetPaletteRealized(arg2);
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 resultobj = SWIG_Py_Void();
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25545 PyObject *resultobj = 0;
25546 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25547 bool result;
25548 void *argp1 = 0 ;
25549 int res1 = 0 ;
25550 PyObject *swig_obj[1] ;
25551
25552 if (!args) SWIG_fail;
25553 swig_obj[0] = args;
25554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25555 if (!SWIG_IsOK(res1)) {
25556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25557 }
25558 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 {
25566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25567 }
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25575 PyObject *obj;
25576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25577 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25578 return SWIG_Py_Void();
25579 }
25580
25581 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25582 return SWIG_Python_InitShadowInstance(args);
25583 }
25584
25585 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxNavigationKeyEvent *result = 0 ;
25588
25589 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25604 PyObject *resultobj = 0;
25605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25606 bool result;
25607 void *argp1 = 0 ;
25608 int res1 = 0 ;
25609 PyObject *swig_obj[1] ;
25610
25611 if (!args) SWIG_fail;
25612 swig_obj[0] = args;
25613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25614 if (!SWIG_IsOK(res1)) {
25615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25616 }
25617 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25618 {
25619 PyThreadState* __tstate = wxPyBeginAllowThreads();
25620 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 {
25625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25626 }
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj = 0;
25635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25636 bool arg2 ;
25637 void *argp1 = 0 ;
25638 int res1 = 0 ;
25639 bool val2 ;
25640 int ecode2 = 0 ;
25641 PyObject * obj0 = 0 ;
25642 PyObject * obj1 = 0 ;
25643 char * kwnames[] = {
25644 (char *) "self",(char *) "forward", NULL
25645 };
25646
25647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25651 }
25652 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25654 if (!SWIG_IsOK(ecode2)) {
25655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25656 }
25657 arg2 = static_cast< bool >(val2);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 (arg1)->SetDirection(arg2);
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 resultobj = SWIG_Py_Void();
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *resultobj = 0;
25673 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25674 bool result;
25675 void *argp1 = 0 ;
25676 int res1 = 0 ;
25677 PyObject *swig_obj[1] ;
25678
25679 if (!args) SWIG_fail;
25680 swig_obj[0] = args;
25681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25682 if (!SWIG_IsOK(res1)) {
25683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25684 }
25685 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 {
25693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "ischange", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25719 }
25720 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25722 if (!SWIG_IsOK(ecode2)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25724 }
25725 arg2 = static_cast< bool >(val2);
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetWindowChange(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_Py_Void();
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25740 PyObject *resultobj = 0;
25741 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25742 bool result;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 PyObject *swig_obj[1] ;
25746
25747 if (!args) SWIG_fail;
25748 swig_obj[0] = args;
25749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25750 if (!SWIG_IsOK(res1)) {
25751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25752 }
25753 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25770 PyObject *resultobj = 0;
25771 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25772 bool arg2 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 bool val2 ;
25776 int ecode2 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 char * kwnames[] = {
25780 (char *) "self",(char *) "bIs", NULL
25781 };
25782
25783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25787 }
25788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25790 if (!SWIG_IsOK(ecode2)) {
25791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25792 }
25793 arg2 = static_cast< bool >(val2);
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 (arg1)->SetFromTab(arg2);
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 resultobj = SWIG_Py_Void();
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj = 0;
25809 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25810 long arg2 ;
25811 void *argp1 = 0 ;
25812 int res1 = 0 ;
25813 long val2 ;
25814 int ecode2 = 0 ;
25815 PyObject * obj0 = 0 ;
25816 PyObject * obj1 = 0 ;
25817 char * kwnames[] = {
25818 (char *) "self",(char *) "flags", NULL
25819 };
25820
25821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25825 }
25826 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25827 ecode2 = SWIG_AsVal_long(obj1, &val2);
25828 if (!SWIG_IsOK(ecode2)) {
25829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25830 }
25831 arg2 = static_cast< long >(val2);
25832 {
25833 PyThreadState* __tstate = wxPyBeginAllowThreads();
25834 (arg1)->SetFlags(arg2);
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 resultobj = SWIG_Py_Void();
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 PyObject *resultobj = 0;
25847 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25848 wxWindow *result = 0 ;
25849 void *argp1 = 0 ;
25850 int res1 = 0 ;
25851 PyObject *swig_obj[1] ;
25852
25853 if (!args) SWIG_fail;
25854 swig_obj[0] = args;
25855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25858 }
25859 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25863 wxPyEndAllowThreads(__tstate);
25864 if (PyErr_Occurred()) SWIG_fail;
25865 }
25866 {
25867 resultobj = wxPyMake_wxObject(result, (bool)0);
25868 }
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj = 0;
25877 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25878 wxWindow *arg2 = (wxWindow *) 0 ;
25879 void *argp1 = 0 ;
25880 int res1 = 0 ;
25881 void *argp2 = 0 ;
25882 int res2 = 0 ;
25883 PyObject * obj0 = 0 ;
25884 PyObject * obj1 = 0 ;
25885 char * kwnames[] = {
25886 (char *) "self",(char *) "win", NULL
25887 };
25888
25889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25891 if (!SWIG_IsOK(res1)) {
25892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25893 }
25894 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25896 if (!SWIG_IsOK(res2)) {
25897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25898 }
25899 arg2 = reinterpret_cast< wxWindow * >(argp2);
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 (arg1)->SetCurrentFocus(arg2);
25903 wxPyEndAllowThreads(__tstate);
25904 if (PyErr_Occurred()) SWIG_fail;
25905 }
25906 resultobj = SWIG_Py_Void();
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25914 PyObject *obj;
25915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25916 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25917 return SWIG_Py_Void();
25918 }
25919
25920 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 return SWIG_Python_InitShadowInstance(args);
25922 }
25923
25924 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj = 0;
25926 wxWindow *arg1 = (wxWindow *) NULL ;
25927 wxWindowCreateEvent *result = 0 ;
25928 void *argp1 = 0 ;
25929 int res1 = 0 ;
25930 PyObject * obj0 = 0 ;
25931 char * kwnames[] = {
25932 (char *) "win", NULL
25933 };
25934
25935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25936 if (obj0) {
25937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25938 if (!SWIG_IsOK(res1)) {
25939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25940 }
25941 arg1 = reinterpret_cast< wxWindow * >(argp1);
25942 }
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *resultobj = 0;
25958 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25959 wxWindow *result = 0 ;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 PyObject *swig_obj[1] ;
25963
25964 if (!args) SWIG_fail;
25965 swig_obj[0] = args;
25966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25969 }
25970 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 {
25978 resultobj = wxPyMake_wxObject(result, (bool)0);
25979 }
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *obj;
25988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25989 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25990 return SWIG_Py_Void();
25991 }
25992
25993 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25994 return SWIG_Python_InitShadowInstance(args);
25995 }
25996
25997 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = 0;
25999 wxWindow *arg1 = (wxWindow *) NULL ;
26000 wxWindowDestroyEvent *result = 0 ;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 PyObject * obj0 = 0 ;
26004 char * kwnames[] = {
26005 (char *) "win", NULL
26006 };
26007
26008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26009 if (obj0) {
26010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26011 if (!SWIG_IsOK(res1)) {
26012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26013 }
26014 arg1 = reinterpret_cast< wxWindow * >(argp1);
26015 }
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26030 PyObject *resultobj = 0;
26031 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26032 wxWindow *result = 0 ;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 PyObject *swig_obj[1] ;
26036
26037 if (!args) SWIG_fail;
26038 swig_obj[0] = args;
26039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26042 }
26043 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 {
26051 resultobj = wxPyMake_wxObject(result, (bool)0);
26052 }
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26060 PyObject *obj;
26061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26062 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26063 return SWIG_Py_Void();
26064 }
26065
26066 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26067 return SWIG_Python_InitShadowInstance(args);
26068 }
26069
26070 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26073 int arg2 = (int) 0 ;
26074 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26075 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26076 wxContextMenuEvent *result = 0 ;
26077 int val1 ;
26078 int ecode1 = 0 ;
26079 int val2 ;
26080 int ecode2 = 0 ;
26081 wxPoint temp3 ;
26082 PyObject * obj0 = 0 ;
26083 PyObject * obj1 = 0 ;
26084 PyObject * obj2 = 0 ;
26085 char * kwnames[] = {
26086 (char *) "type",(char *) "winid",(char *) "pt", NULL
26087 };
26088
26089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26090 if (obj0) {
26091 ecode1 = SWIG_AsVal_int(obj0, &val1);
26092 if (!SWIG_IsOK(ecode1)) {
26093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26094 }
26095 arg1 = static_cast< wxEventType >(val1);
26096 }
26097 if (obj1) {
26098 ecode2 = SWIG_AsVal_int(obj1, &val2);
26099 if (!SWIG_IsOK(ecode2)) {
26100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26101 }
26102 arg2 = static_cast< int >(val2);
26103 }
26104 if (obj2) {
26105 {
26106 arg3 = &temp3;
26107 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26108 }
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26126 wxPoint *result = 0 ;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 PyObject *swig_obj[1] ;
26130
26131 if (!args) SWIG_fail;
26132 swig_obj[0] = args;
26133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26136 }
26137 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 {
26141 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26142 result = (wxPoint *) &_result_ref;
26143 }
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26148 return resultobj;
26149 fail:
26150 return NULL;
26151 }
26152
26153
26154 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj = 0;
26156 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26157 wxPoint *arg2 = 0 ;
26158 void *argp1 = 0 ;
26159 int res1 = 0 ;
26160 wxPoint temp2 ;
26161 PyObject * obj0 = 0 ;
26162 PyObject * obj1 = 0 ;
26163 char * kwnames[] = {
26164 (char *) "self",(char *) "pos", NULL
26165 };
26166
26167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26169 if (!SWIG_IsOK(res1)) {
26170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26171 }
26172 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26173 {
26174 arg2 = &temp2;
26175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->SetPosition((wxPoint const &)*arg2);
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 resultobj = SWIG_Py_Void();
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26191 PyObject *obj;
26192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26193 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26194 return SWIG_Py_Void();
26195 }
26196
26197 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198 return SWIG_Python_InitShadowInstance(args);
26199 }
26200
26201 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 PyObject *resultobj = 0;
26203 wxIdleEvent *result = 0 ;
26204
26205 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (wxIdleEvent *)new wxIdleEvent();
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26222 bool arg2 = (bool) true ;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 bool val2 ;
26226 int ecode2 = 0 ;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "self",(char *) "needMore", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26237 }
26238 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26239 if (obj1) {
26240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26241 if (!SWIG_IsOK(ecode2)) {
26242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26243 }
26244 arg2 = static_cast< bool >(val2);
26245 }
26246 {
26247 PyThreadState* __tstate = wxPyBeginAllowThreads();
26248 (arg1)->RequestMore(arg2);
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 resultobj = SWIG_Py_Void();
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *resultobj = 0;
26261 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26262 bool result;
26263 void *argp1 = 0 ;
26264 int res1 = 0 ;
26265 PyObject *swig_obj[1] ;
26266
26267 if (!args) SWIG_fail;
26268 swig_obj[0] = args;
26269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26272 }
26273 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 {
26281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26282 }
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj = 0;
26291 wxIdleMode arg1 ;
26292 int val1 ;
26293 int ecode1 = 0 ;
26294 PyObject * obj0 = 0 ;
26295 char * kwnames[] = {
26296 (char *) "mode", NULL
26297 };
26298
26299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26300 ecode1 = SWIG_AsVal_int(obj0, &val1);
26301 if (!SWIG_IsOK(ecode1)) {
26302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26303 }
26304 arg1 = static_cast< wxIdleMode >(val1);
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 wxIdleEvent::SetMode(arg1);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_Py_Void();
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 PyObject *resultobj = 0;
26320 wxIdleMode result;
26321
26322 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = (wxIdleMode)wxIdleEvent::GetMode();
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 resultobj = SWIG_From_int(static_cast< int >(result));
26330 return resultobj;
26331 fail:
26332 return NULL;
26333 }
26334
26335
26336 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26337 PyObject *resultobj = 0;
26338 wxWindow *arg1 = (wxWindow *) 0 ;
26339 bool result;
26340 void *argp1 = 0 ;
26341 int res1 = 0 ;
26342 PyObject * obj0 = 0 ;
26343 char * kwnames[] = {
26344 (char *) "win", NULL
26345 };
26346
26347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26349 if (!SWIG_IsOK(res1)) {
26350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26351 }
26352 arg1 = reinterpret_cast< wxWindow * >(argp1);
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (bool)wxIdleEvent::CanSend(arg1);
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 {
26360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26361 }
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26369 PyObject *obj;
26370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26371 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26372 return SWIG_Py_Void();
26373 }
26374
26375 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26376 return SWIG_Python_InitShadowInstance(args);
26377 }
26378
26379 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = 0;
26381 int arg1 = (int) 0 ;
26382 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26383 wxPyEvent *result = 0 ;
26384 int val1 ;
26385 int ecode1 = 0 ;
26386 int val2 ;
26387 int ecode2 = 0 ;
26388 PyObject * obj0 = 0 ;
26389 PyObject * obj1 = 0 ;
26390 char * kwnames[] = {
26391 (char *) "winid",(char *) "eventType", NULL
26392 };
26393
26394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26395 if (obj0) {
26396 ecode1 = SWIG_AsVal_int(obj0, &val1);
26397 if (!SWIG_IsOK(ecode1)) {
26398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26399 }
26400 arg1 = static_cast< int >(val1);
26401 }
26402 if (obj1) {
26403 ecode2 = SWIG_AsVal_int(obj1, &val2);
26404 if (!SWIG_IsOK(ecode2)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26406 }
26407 arg2 = static_cast< wxEventType >(val2);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *resultobj = 0;
26424 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 PyObject *swig_obj[1] ;
26428
26429 if (!args) SWIG_fail;
26430 swig_obj[0] = args;
26431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26434 }
26435 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 delete arg1;
26439
26440 wxPyEndAllowThreads(__tstate);
26441 if (PyErr_Occurred()) SWIG_fail;
26442 }
26443 resultobj = SWIG_Py_Void();
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26451 PyObject *resultobj = 0;
26452 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26453 PyObject *arg2 = (PyObject *) 0 ;
26454 void *argp1 = 0 ;
26455 int res1 = 0 ;
26456 PyObject * obj0 = 0 ;
26457 PyObject * obj1 = 0 ;
26458 char * kwnames[] = {
26459 (char *) "self",(char *) "self", NULL
26460 };
26461
26462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26464 if (!SWIG_IsOK(res1)) {
26465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26466 }
26467 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26468 arg2 = obj1;
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 (arg1)->SetSelf(arg2);
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 resultobj = SWIG_Py_Void();
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483 PyObject *resultobj = 0;
26484 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26485 PyObject *result = 0 ;
26486 void *argp1 = 0 ;
26487 int res1 = 0 ;
26488 PyObject *swig_obj[1] ;
26489
26490 if (!args) SWIG_fail;
26491 swig_obj[0] = args;
26492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26493 if (!SWIG_IsOK(res1)) {
26494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26495 }
26496 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26497 {
26498 PyThreadState* __tstate = wxPyBeginAllowThreads();
26499 result = (PyObject *)(arg1)->GetSelf();
26500 wxPyEndAllowThreads(__tstate);
26501 if (PyErr_Occurred()) SWIG_fail;
26502 }
26503 resultobj = result;
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26511 PyObject *obj;
26512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26513 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26514 return SWIG_Py_Void();
26515 }
26516
26517 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 return SWIG_Python_InitShadowInstance(args);
26519 }
26520
26521 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj = 0;
26523 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26524 int arg2 = (int) 0 ;
26525 wxPyCommandEvent *result = 0 ;
26526 int val1 ;
26527 int ecode1 = 0 ;
26528 int val2 ;
26529 int ecode2 = 0 ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "eventType",(char *) "id", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26537 if (obj0) {
26538 ecode1 = SWIG_AsVal_int(obj0, &val1);
26539 if (!SWIG_IsOK(ecode1)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26541 }
26542 arg1 = static_cast< wxEventType >(val1);
26543 }
26544 if (obj1) {
26545 ecode2 = SWIG_AsVal_int(obj1, &val2);
26546 if (!SWIG_IsOK(ecode2)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26548 }
26549 arg2 = static_cast< int >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 PyObject *swig_obj[1] ;
26570
26571 if (!args) SWIG_fail;
26572 swig_obj[0] = args;
26573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26574 if (!SWIG_IsOK(res1)) {
26575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26576 }
26577 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_Py_Void();
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26595 PyObject *arg2 = (PyObject *) 0 ;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char * kwnames[] = {
26601 (char *) "self",(char *) "self", NULL
26602 };
26603
26604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26606 if (!SWIG_IsOK(res1)) {
26607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26608 }
26609 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26610 arg2 = obj1;
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->SetSelf(arg2);
26614 wxPyEndAllowThreads(__tstate);
26615 if (PyErr_Occurred()) SWIG_fail;
26616 }
26617 resultobj = SWIG_Py_Void();
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 PyObject *resultobj = 0;
26626 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26627 PyObject *result = 0 ;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 PyObject *swig_obj[1] ;
26631
26632 if (!args) SWIG_fail;
26633 swig_obj[0] = args;
26634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26635 if (!SWIG_IsOK(res1)) {
26636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26637 }
26638 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (PyObject *)(arg1)->GetSelf();
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = result;
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653 PyObject *obj;
26654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26656 return SWIG_Py_Void();
26657 }
26658
26659 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26660 return SWIG_Python_InitShadowInstance(args);
26661 }
26662
26663 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxWindow *arg1 = (wxWindow *) 0 ;
26666 wxDateTime *arg2 = 0 ;
26667 wxEventType arg3 ;
26668 wxDateEvent *result = 0 ;
26669 void *argp1 = 0 ;
26670 int res1 = 0 ;
26671 void *argp2 = 0 ;
26672 int res2 = 0 ;
26673 int val3 ;
26674 int ecode3 = 0 ;
26675 PyObject * obj0 = 0 ;
26676 PyObject * obj1 = 0 ;
26677 PyObject * obj2 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "win",(char *) "dt",(char *) "type", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26686 }
26687 arg1 = reinterpret_cast< wxWindow * >(argp1);
26688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26689 if (!SWIG_IsOK(res2)) {
26690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26691 }
26692 if (!argp2) {
26693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26694 }
26695 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26696 ecode3 = SWIG_AsVal_int(obj2, &val3);
26697 if (!SWIG_IsOK(ecode3)) {
26698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26699 }
26700 arg3 = static_cast< wxEventType >(val3);
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26717 wxDateTime *result = 0 ;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 PyObject *swig_obj[1] ;
26721
26722 if (!args) SWIG_fail;
26723 swig_obj[0] = args;
26724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26727 }
26728 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 {
26732 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26733 result = (wxDateTime *) &_result_ref;
26734 }
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26746 PyObject *resultobj = 0;
26747 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26748 wxDateTime *arg2 = 0 ;
26749 void *argp1 = 0 ;
26750 int res1 = 0 ;
26751 void *argp2 = 0 ;
26752 int res2 = 0 ;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755 char * kwnames[] = {
26756 (char *) "self",(char *) "date", NULL
26757 };
26758
26759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26761 if (!SWIG_IsOK(res1)) {
26762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26763 }
26764 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26766 if (!SWIG_IsOK(res2)) {
26767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26768 }
26769 if (!argp2) {
26770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26771 }
26772 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26773 {
26774 PyThreadState* __tstate = wxPyBeginAllowThreads();
26775 (arg1)->SetDate((wxDateTime const &)*arg2);
26776 wxPyEndAllowThreads(__tstate);
26777 if (PyErr_Occurred()) SWIG_fail;
26778 }
26779 resultobj = SWIG_Py_Void();
26780 return resultobj;
26781 fail:
26782 return NULL;
26783 }
26784
26785
26786 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26787 PyObject *obj;
26788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26789 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26790 return SWIG_Py_Void();
26791 }
26792
26793 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 return SWIG_Python_InitShadowInstance(args);
26795 }
26796
26797 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxPyApp *result = 0 ;
26800
26801 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26802 {
26803 PyThreadState* __tstate = wxPyBeginAllowThreads();
26804 result = (wxPyApp *)new_wxPyApp();
26805 wxPyEndAllowThreads(__tstate);
26806 if (PyErr_Occurred()) SWIG_fail;
26807 }
26808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26809 return resultobj;
26810 fail:
26811 return NULL;
26812 }
26813
26814
26815 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26816 PyObject *resultobj = 0;
26817 wxPyApp *arg1 = (wxPyApp *) 0 ;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 PyObject *swig_obj[1] ;
26821
26822 if (!args) SWIG_fail;
26823 swig_obj[0] = args;
26824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26825 if (!SWIG_IsOK(res1)) {
26826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26827 }
26828 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 delete arg1;
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 resultobj = SWIG_Py_Void();
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj = 0;
26845 wxPyApp *arg1 = (wxPyApp *) 0 ;
26846 PyObject *arg2 = (PyObject *) 0 ;
26847 PyObject *arg3 = (PyObject *) 0 ;
26848 bool arg4 ;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 bool val4 ;
26852 int ecode4 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 PyObject * obj2 = 0 ;
26856 PyObject * obj3 = 0 ;
26857 char * kwnames[] = {
26858 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26859 };
26860
26861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26863 if (!SWIG_IsOK(res1)) {
26864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26865 }
26866 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26867 arg2 = obj1;
26868 arg3 = obj2;
26869 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26870 if (!SWIG_IsOK(ecode4)) {
26871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26872 }
26873 arg4 = static_cast< bool >(val4);
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_Py_Void();
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *resultobj = 0;
26889 wxPyApp *arg1 = (wxPyApp *) 0 ;
26890 wxString result;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 PyObject *swig_obj[1] ;
26894
26895 if (!args) SWIG_fail;
26896 swig_obj[0] = args;
26897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26900 }
26901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 result = ((wxPyApp const *)arg1)->GetAppName();
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 {
26909 #if wxUSE_UNICODE
26910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26911 #else
26912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26913 #endif
26914 }
26915 return resultobj;
26916 fail:
26917 return NULL;
26918 }
26919
26920
26921 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26922 PyObject *resultobj = 0;
26923 wxPyApp *arg1 = (wxPyApp *) 0 ;
26924 wxString *arg2 = 0 ;
26925 void *argp1 = 0 ;
26926 int res1 = 0 ;
26927 bool temp2 = false ;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char * kwnames[] = {
26931 (char *) "self",(char *) "name", NULL
26932 };
26933
26934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26936 if (!SWIG_IsOK(res1)) {
26937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26938 }
26939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26940 {
26941 arg2 = wxString_in_helper(obj1);
26942 if (arg2 == NULL) SWIG_fail;
26943 temp2 = true;
26944 }
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 (arg1)->SetAppName((wxString const &)*arg2);
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 resultobj = SWIG_Py_Void();
26952 {
26953 if (temp2)
26954 delete arg2;
26955 }
26956 return resultobj;
26957 fail:
26958 {
26959 if (temp2)
26960 delete arg2;
26961 }
26962 return NULL;
26963 }
26964
26965
26966 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26967 PyObject *resultobj = 0;
26968 wxPyApp *arg1 = (wxPyApp *) 0 ;
26969 wxString result;
26970 void *argp1 = 0 ;
26971 int res1 = 0 ;
26972 PyObject *swig_obj[1] ;
26973
26974 if (!args) SWIG_fail;
26975 swig_obj[0] = args;
26976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26977 if (!SWIG_IsOK(res1)) {
26978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26979 }
26980 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = ((wxPyApp const *)arg1)->GetClassName();
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 #if wxUSE_UNICODE
26989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26990 #else
26991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26992 #endif
26993 }
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxPyApp *arg1 = (wxPyApp *) 0 ;
27003 wxString *arg2 = 0 ;
27004 void *argp1 = 0 ;
27005 int res1 = 0 ;
27006 bool temp2 = false ;
27007 PyObject * obj0 = 0 ;
27008 PyObject * obj1 = 0 ;
27009 char * kwnames[] = {
27010 (char *) "self",(char *) "name", NULL
27011 };
27012
27013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27015 if (!SWIG_IsOK(res1)) {
27016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27017 }
27018 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27019 {
27020 arg2 = wxString_in_helper(obj1);
27021 if (arg2 == NULL) SWIG_fail;
27022 temp2 = true;
27023 }
27024 {
27025 PyThreadState* __tstate = wxPyBeginAllowThreads();
27026 (arg1)->SetClassName((wxString const &)*arg2);
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 {
27032 if (temp2)
27033 delete arg2;
27034 }
27035 return resultobj;
27036 fail:
27037 {
27038 if (temp2)
27039 delete arg2;
27040 }
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxPyApp *arg1 = (wxPyApp *) 0 ;
27048 wxString *result = 0 ;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27058 }
27059 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 {
27063 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27064 result = (wxString *) &_result_ref;
27065 }
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 {
27070 #if wxUSE_UNICODE
27071 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27072 #else
27073 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27074 #endif
27075 }
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj = 0;
27084 wxPyApp *arg1 = (wxPyApp *) 0 ;
27085 wxString *arg2 = 0 ;
27086 void *argp1 = 0 ;
27087 int res1 = 0 ;
27088 bool temp2 = false ;
27089 PyObject * obj0 = 0 ;
27090 PyObject * obj1 = 0 ;
27091 char * kwnames[] = {
27092 (char *) "self",(char *) "name", NULL
27093 };
27094
27095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27097 if (!SWIG_IsOK(res1)) {
27098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27099 }
27100 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27101 {
27102 arg2 = wxString_in_helper(obj1);
27103 if (arg2 == NULL) SWIG_fail;
27104 temp2 = true;
27105 }
27106 {
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 (arg1)->SetVendorName((wxString const &)*arg2);
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 resultobj = SWIG_Py_Void();
27113 {
27114 if (temp2)
27115 delete arg2;
27116 }
27117 return resultobj;
27118 fail:
27119 {
27120 if (temp2)
27121 delete arg2;
27122 }
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27128 PyObject *resultobj = 0;
27129 wxPyApp *arg1 = (wxPyApp *) 0 ;
27130 wxAppTraits *result = 0 ;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 PyObject *swig_obj[1] ;
27134
27135 if (!args) SWIG_fail;
27136 swig_obj[0] = args;
27137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27138 if (!SWIG_IsOK(res1)) {
27139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27140 }
27141 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (wxAppTraits *)(arg1)->GetTraits();
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxPyApp *arg1 = (wxPyApp *) 0 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 PyObject *swig_obj[1] ;
27161
27162 if (!args) SWIG_fail;
27163 swig_obj[0] = args;
27164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27167 }
27168 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 (arg1)->ProcessPendingEvents();
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 resultobj = SWIG_Py_Void();
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27183 PyObject *resultobj = 0;
27184 wxPyApp *arg1 = (wxPyApp *) 0 ;
27185 bool arg2 = (bool) false ;
27186 bool result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 bool val2 ;
27190 int ecode2 = 0 ;
27191 PyObject * obj0 = 0 ;
27192 PyObject * obj1 = 0 ;
27193 char * kwnames[] = {
27194 (char *) "self",(char *) "onlyIfNeeded", NULL
27195 };
27196
27197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27199 if (!SWIG_IsOK(res1)) {
27200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27201 }
27202 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27203 if (obj1) {
27204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27205 if (!SWIG_IsOK(ecode2)) {
27206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27207 }
27208 arg2 = static_cast< bool >(val2);
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (bool)(arg1)->Yield(arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 {
27217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27218 }
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxPyApp *arg1 = (wxPyApp *) 0 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 PyObject *swig_obj[1] ;
27231
27232 if (!args) SWIG_fail;
27233 swig_obj[0] = args;
27234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27237 }
27238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 (arg1)->WakeUpIdle();
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 resultobj = SWIG_Py_Void();
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27253 PyObject *resultobj = 0;
27254 bool result;
27255
27256 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 result = (bool)wxPyApp::IsMainLoopRunning();
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 {
27264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27265 }
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27273 PyObject *resultobj = 0;
27274 wxPyApp *arg1 = (wxPyApp *) 0 ;
27275 int result;
27276 void *argp1 = 0 ;
27277 int res1 = 0 ;
27278 PyObject *swig_obj[1] ;
27279
27280 if (!args) SWIG_fail;
27281 swig_obj[0] = args;
27282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27283 if (!SWIG_IsOK(res1)) {
27284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27285 }
27286 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (int)(arg1)->MainLoop();
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 resultobj = SWIG_From_int(static_cast< int >(result));
27294 return resultobj;
27295 fail:
27296 return NULL;
27297 }
27298
27299
27300 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27301 PyObject *resultobj = 0;
27302 wxPyApp *arg1 = (wxPyApp *) 0 ;
27303 void *argp1 = 0 ;
27304 int res1 = 0 ;
27305 PyObject *swig_obj[1] ;
27306
27307 if (!args) SWIG_fail;
27308 swig_obj[0] = args;
27309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27310 if (!SWIG_IsOK(res1)) {
27311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27312 }
27313 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 (arg1)->Exit();
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 resultobj = SWIG_Py_Void();
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27328 PyObject *resultobj = 0;
27329 wxPyApp *arg1 = (wxPyApp *) 0 ;
27330 void *argp1 = 0 ;
27331 int res1 = 0 ;
27332 PyObject *swig_obj[1] ;
27333
27334 if (!args) SWIG_fail;
27335 swig_obj[0] = args;
27336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27339 }
27340 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 (arg1)->ExitMainLoop();
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 resultobj = SWIG_Py_Void();
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *arg1 = (wxPyApp *) 0 ;
27357 bool result;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 PyObject *swig_obj[1] ;
27361
27362 if (!args) SWIG_fail;
27363 swig_obj[0] = args;
27364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = (bool)(arg1)->Pending();
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27377 }
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *resultobj = 0;
27386 wxPyApp *arg1 = (wxPyApp *) 0 ;
27387 bool result;
27388 void *argp1 = 0 ;
27389 int res1 = 0 ;
27390 PyObject *swig_obj[1] ;
27391
27392 if (!args) SWIG_fail;
27393 swig_obj[0] = args;
27394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27395 if (!SWIG_IsOK(res1)) {
27396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27397 }
27398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)(arg1)->Dispatch();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 bool result;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (bool)(arg1)->ProcessIdle();
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 {
27436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27437 }
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj = 0;
27446 wxPyApp *arg1 = (wxPyApp *) 0 ;
27447 wxWindow *arg2 = (wxWindow *) 0 ;
27448 wxIdleEvent *arg3 = 0 ;
27449 bool result;
27450 void *argp1 = 0 ;
27451 int res1 = 0 ;
27452 void *argp2 = 0 ;
27453 int res2 = 0 ;
27454 void *argp3 = 0 ;
27455 int res3 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 PyObject * obj2 = 0 ;
27459 char * kwnames[] = {
27460 (char *) "self",(char *) "win",(char *) "event", NULL
27461 };
27462
27463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27465 if (!SWIG_IsOK(res1)) {
27466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27467 }
27468 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27470 if (!SWIG_IsOK(res2)) {
27471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27472 }
27473 arg2 = reinterpret_cast< wxWindow * >(argp2);
27474 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27475 if (!SWIG_IsOK(res3)) {
27476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27477 }
27478 if (!argp3) {
27479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27480 }
27481 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27485 wxPyEndAllowThreads(__tstate);
27486 if (PyErr_Occurred()) SWIG_fail;
27487 }
27488 {
27489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27490 }
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxPyApp *arg1 = (wxPyApp *) 0 ;
27500 bool result;
27501 void *argp1 = 0 ;
27502 int res1 = 0 ;
27503 PyObject *swig_obj[1] ;
27504
27505 if (!args) SWIG_fail;
27506 swig_obj[0] = args;
27507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (bool)((wxPyApp const *)arg1)->IsActive();
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 {
27519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 wxWindow *arg2 = (wxWindow *) 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 void *argp2 = 0 ;
27534 int res2 = 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "self",(char *) "win", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27548 if (!SWIG_IsOK(res2)) {
27549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27550 }
27551 arg2 = reinterpret_cast< wxWindow * >(argp2);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 (arg1)->SetTopWindow(arg2);
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 resultobj = SWIG_Py_Void();
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27566 PyObject *resultobj = 0;
27567 wxPyApp *arg1 = (wxPyApp *) 0 ;
27568 wxWindow *result = 0 ;
27569 void *argp1 = 0 ;
27570 int res1 = 0 ;
27571 PyObject *swig_obj[1] ;
27572
27573 if (!args) SWIG_fail;
27574 swig_obj[0] = args;
27575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27576 if (!SWIG_IsOK(res1)) {
27577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27578 }
27579 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = wxPyMake_wxObject(result, (bool)0);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = 0;
27597 wxPyApp *arg1 = (wxPyApp *) 0 ;
27598 bool arg2 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 bool val2 ;
27602 int ecode2 = 0 ;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char * kwnames[] = {
27606 (char *) "self",(char *) "flag", NULL
27607 };
27608
27609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27613 }
27614 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27616 if (!SWIG_IsOK(ecode2)) {
27617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27618 }
27619 arg2 = static_cast< bool >(val2);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 (arg1)->SetExitOnFrameDelete(arg2);
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 resultobj = SWIG_Py_Void();
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 bool result;
27637 void *argp1 = 0 ;
27638 int res1 = 0 ;
27639 PyObject *swig_obj[1] ;
27640
27641 if (!args) SWIG_fail;
27642 swig_obj[0] = args;
27643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 bool arg2 ;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 bool val2 ;
27670 int ecode2 = 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char * kwnames[] = {
27674 (char *) "self",(char *) "flag", NULL
27675 };
27676
27677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27681 }
27682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27684 if (!SWIG_IsOK(ecode2)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27686 }
27687 arg2 = static_cast< bool >(val2);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 (arg1)->SetUseBestVisual(arg2);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_Py_Void();
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 bool result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27714 }
27715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj = 0;
27733 wxPyApp *arg1 = (wxPyApp *) 0 ;
27734 int arg2 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 int val2 ;
27738 int ecode2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "mode", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27749 }
27750 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27751 ecode2 = SWIG_AsVal_int(obj1, &val2);
27752 if (!SWIG_IsOK(ecode2)) {
27753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27754 }
27755 arg2 = static_cast< int >(val2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 (arg1)->SetPrintMode(arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_Py_Void();
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 wxPyApp *arg1 = (wxPyApp *) 0 ;
27772 int result;
27773 void *argp1 = 0 ;
27774 int res1 = 0 ;
27775 PyObject *swig_obj[1] ;
27776
27777 if (!args) SWIG_fail;
27778 swig_obj[0] = args;
27779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27780 if (!SWIG_IsOK(res1)) {
27781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27782 }
27783 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 resultobj = SWIG_From_int(static_cast< int >(result));
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj = 0;
27799 wxPyApp *arg1 = (wxPyApp *) 0 ;
27800 int arg2 ;
27801 void *argp1 = 0 ;
27802 int res1 = 0 ;
27803 int val2 ;
27804 int ecode2 = 0 ;
27805 PyObject * obj0 = 0 ;
27806 PyObject * obj1 = 0 ;
27807 char * kwnames[] = {
27808 (char *) "self",(char *) "mode", NULL
27809 };
27810
27811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27815 }
27816 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27817 ecode2 = SWIG_AsVal_int(obj1, &val2);
27818 if (!SWIG_IsOK(ecode2)) {
27819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27820 }
27821 arg2 = static_cast< int >(val2);
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 (arg1)->SetAssertMode(arg2);
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 resultobj = SWIG_Py_Void();
27829 return resultobj;
27830 fail:
27831 return NULL;
27832 }
27833
27834
27835 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27836 PyObject *resultobj = 0;
27837 wxPyApp *arg1 = (wxPyApp *) 0 ;
27838 int result;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 PyObject *swig_obj[1] ;
27842
27843 if (!args) SWIG_fail;
27844 swig_obj[0] = args;
27845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27846 if (!SWIG_IsOK(res1)) {
27847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27848 }
27849 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 result = (int)(arg1)->GetAssertMode();
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 resultobj = SWIG_From_int(static_cast< int >(result));
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27864 PyObject *resultobj = 0;
27865 bool result;
27866
27867 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 {
27875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27876 }
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27884 PyObject *resultobj = 0;
27885 long result;
27886
27887 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 result = (long)wxPyApp::GetMacAboutMenuItemId();
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 resultobj = SWIG_From_long(static_cast< long >(result));
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 long result;
27904
27905 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_From_long(static_cast< long >(result));
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 long result;
27922
27923 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (long)wxPyApp::GetMacExitMenuItemId();
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 resultobj = SWIG_From_long(static_cast< long >(result));
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27938 PyObject *resultobj = 0;
27939 wxString result;
27940
27941 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = wxPyApp::GetMacHelpMenuTitleName();
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 #if wxUSE_UNICODE
27950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27951 #else
27952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27953 #endif
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = 0;
27963 bool arg1 ;
27964 bool val1 ;
27965 int ecode1 = 0 ;
27966 PyObject * obj0 = 0 ;
27967 char * kwnames[] = {
27968 (char *) "val", NULL
27969 };
27970
27971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27972 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27973 if (!SWIG_IsOK(ecode1)) {
27974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27975 }
27976 arg1 = static_cast< bool >(val1);
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 resultobj = SWIG_Py_Void();
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj = 0;
27992 long arg1 ;
27993 long val1 ;
27994 int ecode1 = 0 ;
27995 PyObject * obj0 = 0 ;
27996 char * kwnames[] = {
27997 (char *) "val", NULL
27998 };
27999
28000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28001 ecode1 = SWIG_AsVal_long(obj0, &val1);
28002 if (!SWIG_IsOK(ecode1)) {
28003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28004 }
28005 arg1 = static_cast< long >(val1);
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 wxPyApp::SetMacAboutMenuItemId(arg1);
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 resultobj = SWIG_Py_Void();
28013 return resultobj;
28014 fail:
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28020 PyObject *resultobj = 0;
28021 long arg1 ;
28022 long val1 ;
28023 int ecode1 = 0 ;
28024 PyObject * obj0 = 0 ;
28025 char * kwnames[] = {
28026 (char *) "val", NULL
28027 };
28028
28029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28030 ecode1 = SWIG_AsVal_long(obj0, &val1);
28031 if (!SWIG_IsOK(ecode1)) {
28032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28033 }
28034 arg1 = static_cast< long >(val1);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 wxPyApp::SetMacPreferencesMenuItemId(arg1);
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_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28049 PyObject *resultobj = 0;
28050 long arg1 ;
28051 long val1 ;
28052 int ecode1 = 0 ;
28053 PyObject * obj0 = 0 ;
28054 char * kwnames[] = {
28055 (char *) "val", NULL
28056 };
28057
28058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28059 ecode1 = SWIG_AsVal_long(obj0, &val1);
28060 if (!SWIG_IsOK(ecode1)) {
28061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28062 }
28063 arg1 = static_cast< long >(val1);
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 wxPyApp::SetMacExitMenuItemId(arg1);
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_Py_Void();
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj = 0;
28079 wxString *arg1 = 0 ;
28080 bool temp1 = false ;
28081 PyObject * obj0 = 0 ;
28082 char * kwnames[] = {
28083 (char *) "val", NULL
28084 };
28085
28086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28087 {
28088 arg1 = wxString_in_helper(obj0);
28089 if (arg1 == NULL) SWIG_fail;
28090 temp1 = true;
28091 }
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28095 wxPyEndAllowThreads(__tstate);
28096 if (PyErr_Occurred()) SWIG_fail;
28097 }
28098 resultobj = SWIG_Py_Void();
28099 {
28100 if (temp1)
28101 delete arg1;
28102 }
28103 return resultobj;
28104 fail:
28105 {
28106 if (temp1)
28107 delete arg1;
28108 }
28109 return NULL;
28110 }
28111
28112
28113 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28114 PyObject *resultobj = 0;
28115 wxPyApp *arg1 = (wxPyApp *) 0 ;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 PyObject *swig_obj[1] ;
28119
28120 if (!args) SWIG_fail;
28121 swig_obj[0] = args;
28122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28123 if (!SWIG_IsOK(res1)) {
28124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28125 }
28126 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 (arg1)->_BootstrapApp();
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 resultobj = SWIG_Py_Void();
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28141 PyObject *resultobj = 0;
28142 int result;
28143
28144 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (int)wxPyApp_GetComCtl32Version();
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 resultobj = SWIG_From_int(static_cast< int >(result));
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28159 PyObject *obj;
28160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28161 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28162 return SWIG_Py_Void();
28163 }
28164
28165 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28166 return SWIG_Python_InitShadowInstance(args);
28167 }
28168
28169 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171
28172 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 wxExit();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_Py_Void();
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 bool result;
28189
28190 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = (bool)wxYield();
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 {
28198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28199 }
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28207 PyObject *resultobj = 0;
28208 bool result;
28209
28210 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (bool)wxYieldIfNeeded();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj = 0;
28228 wxWindow *arg1 = (wxWindow *) NULL ;
28229 bool arg2 = (bool) false ;
28230 bool result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 bool val2 ;
28234 int ecode2 = 0 ;
28235 PyObject * obj0 = 0 ;
28236 PyObject * obj1 = 0 ;
28237 char * kwnames[] = {
28238 (char *) "win",(char *) "onlyIfNeeded", NULL
28239 };
28240
28241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28242 if (obj0) {
28243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28244 if (!SWIG_IsOK(res1)) {
28245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28246 }
28247 arg1 = reinterpret_cast< wxWindow * >(argp1);
28248 }
28249 if (obj1) {
28250 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28251 if (!SWIG_IsOK(ecode2)) {
28252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28253 }
28254 arg2 = static_cast< bool >(val2);
28255 }
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (bool)wxSafeYield(arg1,arg2);
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 {
28263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28264 }
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28272 PyObject *resultobj = 0;
28273
28274 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 wxWakeUpIdle();
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 resultobj = SWIG_Py_Void();
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj = 0;
28290 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28291 wxEvent *arg2 = 0 ;
28292 void *argp1 = 0 ;
28293 int res1 = 0 ;
28294 void *argp2 = 0 ;
28295 int res2 = 0 ;
28296 PyObject * obj0 = 0 ;
28297 PyObject * obj1 = 0 ;
28298 char * kwnames[] = {
28299 (char *) "dest",(char *) "event", NULL
28300 };
28301
28302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28304 if (!SWIG_IsOK(res1)) {
28305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28306 }
28307 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28309 if (!SWIG_IsOK(res2)) {
28310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28311 }
28312 if (!argp2) {
28313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28314 }
28315 arg2 = reinterpret_cast< wxEvent * >(argp2);
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 wxPostEvent(arg1,*arg2);
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_Py_Void();
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 PyObject *resultobj = 0;
28331
28332 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 wxApp_CleanUp();
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 resultobj = SWIG_Py_Void();
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 PyObject *resultobj = 0;
28348 wxPyApp *result = 0 ;
28349
28350 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (wxPyApp *)wxPyGetApp();
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 {
28358 resultobj = wxPyMake_wxObject(result, 0);
28359 }
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28367 PyObject *resultobj = 0;
28368 char *arg1 = (char *) 0 ;
28369 int res1 ;
28370 char *buf1 = 0 ;
28371 int alloc1 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 char * kwnames[] = {
28374 (char *) "encoding", NULL
28375 };
28376
28377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28378 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28379 if (!SWIG_IsOK(res1)) {
28380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28381 }
28382 arg1 = buf1;
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 wxSetDefaultPyEncoding((char const *)arg1);
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_Py_Void();
28390 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28391 return resultobj;
28392 fail:
28393 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 PyObject *resultobj = 0;
28400 char *result = 0 ;
28401
28402 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (char *)wxGetDefaultPyEncoding();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 resultobj = SWIG_FromCharPtr(result);
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 PyObject *resultobj = 0;
28418 wxEventLoop *result = 0 ;
28419
28420 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxEventLoop *)new wxEventLoop();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28435 PyObject *resultobj = 0;
28436 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28437 void *argp1 = 0 ;
28438 int res1 = 0 ;
28439 PyObject *swig_obj[1] ;
28440
28441 if (!args) SWIG_fail;
28442 swig_obj[0] = args;
28443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28444 if (!SWIG_IsOK(res1)) {
28445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28446 }
28447 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28448 {
28449 PyThreadState* __tstate = wxPyBeginAllowThreads();
28450 delete arg1;
28451
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 resultobj = SWIG_Py_Void();
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463 PyObject *resultobj = 0;
28464 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28465 int result;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 PyObject *swig_obj[1] ;
28469
28470 if (!args) SWIG_fail;
28471 swig_obj[0] = args;
28472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28473 if (!SWIG_IsOK(res1)) {
28474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28475 }
28476 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (int)(arg1)->Run();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_From_int(static_cast< int >(result));
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj = 0;
28492 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28493 int arg2 = (int) 0 ;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 int val2 ;
28497 int ecode2 = 0 ;
28498 PyObject * obj0 = 0 ;
28499 PyObject * obj1 = 0 ;
28500 char * kwnames[] = {
28501 (char *) "self",(char *) "rc", NULL
28502 };
28503
28504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28506 if (!SWIG_IsOK(res1)) {
28507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28508 }
28509 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28510 if (obj1) {
28511 ecode2 = SWIG_AsVal_int(obj1, &val2);
28512 if (!SWIG_IsOK(ecode2)) {
28513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28514 }
28515 arg2 = static_cast< int >(val2);
28516 }
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 (arg1)->Exit(arg2);
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 resultobj = SWIG_Py_Void();
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *resultobj = 0;
28532 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28533 bool result;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 PyObject *swig_obj[1] ;
28537
28538 if (!args) SWIG_fail;
28539 swig_obj[0] = args;
28540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28543 }
28544 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (bool)((wxEventLoop const *)arg1)->Pending();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 {
28552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28553 }
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28561 PyObject *resultobj = 0;
28562 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28563 bool result;
28564 void *argp1 = 0 ;
28565 int res1 = 0 ;
28566 PyObject *swig_obj[1] ;
28567
28568 if (!args) SWIG_fail;
28569 swig_obj[0] = args;
28570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28571 if (!SWIG_IsOK(res1)) {
28572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28573 }
28574 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (bool)(arg1)->Dispatch();
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 {
28582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28583 }
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591 PyObject *resultobj = 0;
28592 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28593 bool result;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28603 }
28604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 {
28612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28613 }
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxEventLoop *result = 0 ;
28623
28624 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (wxEventLoop *)wxEventLoop::GetActive();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = 0;
28640 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28641 void *argp1 = 0 ;
28642 int res1 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 char * kwnames[] = {
28645 (char *) "loop", NULL
28646 };
28647
28648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28652 }
28653 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 wxEventLoop::SetActive(arg1);
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_Py_Void();
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *obj;
28669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28670 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28671 return SWIG_Py_Void();
28672 }
28673
28674 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 return SWIG_Python_InitShadowInstance(args);
28676 }
28677
28678 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28681 wxEventLoopActivator *result = 0 ;
28682 void *argp1 = 0 ;
28683 int res1 = 0 ;
28684 PyObject * obj0 = 0 ;
28685 char * kwnames[] = {
28686 (char *) "evtLoop", NULL
28687 };
28688
28689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28691 if (!SWIG_IsOK(res1)) {
28692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28693 }
28694 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28709 PyObject *resultobj = 0;
28710 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28711 void *argp1 = 0 ;
28712 int res1 = 0 ;
28713 PyObject *swig_obj[1] ;
28714
28715 if (!args) SWIG_fail;
28716 swig_obj[0] = args;
28717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28718 if (!SWIG_IsOK(res1)) {
28719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28720 }
28721 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 delete arg1;
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_Py_Void();
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *obj;
28738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28739 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28740 return SWIG_Py_Void();
28741 }
28742
28743 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 return SWIG_Python_InitShadowInstance(args);
28745 }
28746
28747 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28748 PyObject *resultobj = 0;
28749 int arg1 = (int) 0 ;
28750 int arg2 = (int) 0 ;
28751 int arg3 = (int) 0 ;
28752 wxAcceleratorEntry *result = 0 ;
28753 int val1 ;
28754 int ecode1 = 0 ;
28755 int val2 ;
28756 int ecode2 = 0 ;
28757 int val3 ;
28758 int ecode3 = 0 ;
28759 PyObject * obj0 = 0 ;
28760 PyObject * obj1 = 0 ;
28761 PyObject * obj2 = 0 ;
28762 char * kwnames[] = {
28763 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28764 };
28765
28766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28767 if (obj0) {
28768 ecode1 = SWIG_AsVal_int(obj0, &val1);
28769 if (!SWIG_IsOK(ecode1)) {
28770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28771 }
28772 arg1 = static_cast< int >(val1);
28773 }
28774 if (obj1) {
28775 ecode2 = SWIG_AsVal_int(obj1, &val2);
28776 if (!SWIG_IsOK(ecode2)) {
28777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28778 }
28779 arg2 = static_cast< int >(val2);
28780 }
28781 if (obj2) {
28782 ecode3 = SWIG_AsVal_int(obj2, &val3);
28783 if (!SWIG_IsOK(ecode3)) {
28784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28785 }
28786 arg3 = static_cast< int >(val3);
28787 }
28788 {
28789 PyThreadState* __tstate = wxPyBeginAllowThreads();
28790 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28791 wxPyEndAllowThreads(__tstate);
28792 if (PyErr_Occurred()) SWIG_fail;
28793 }
28794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28795 return resultobj;
28796 fail:
28797 return NULL;
28798 }
28799
28800
28801 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28802 PyObject *resultobj = 0;
28803 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28804 void *argp1 = 0 ;
28805 int res1 = 0 ;
28806 PyObject *swig_obj[1] ;
28807
28808 if (!args) SWIG_fail;
28809 swig_obj[0] = args;
28810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28811 if (!SWIG_IsOK(res1)) {
28812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28813 }
28814 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 delete arg1;
28818
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 resultobj = SWIG_Py_Void();
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28830 PyObject *resultobj = 0;
28831 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28832 int arg2 ;
28833 int arg3 ;
28834 int arg4 ;
28835 void *argp1 = 0 ;
28836 int res1 = 0 ;
28837 int val2 ;
28838 int ecode2 = 0 ;
28839 int val3 ;
28840 int ecode3 = 0 ;
28841 int val4 ;
28842 int ecode4 = 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 PyObject * obj3 = 0 ;
28847 char * kwnames[] = {
28848 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28849 };
28850
28851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28853 if (!SWIG_IsOK(res1)) {
28854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28855 }
28856 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28857 ecode2 = SWIG_AsVal_int(obj1, &val2);
28858 if (!SWIG_IsOK(ecode2)) {
28859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28860 }
28861 arg2 = static_cast< int >(val2);
28862 ecode3 = SWIG_AsVal_int(obj2, &val3);
28863 if (!SWIG_IsOK(ecode3)) {
28864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28865 }
28866 arg3 = static_cast< int >(val3);
28867 ecode4 = SWIG_AsVal_int(obj3, &val4);
28868 if (!SWIG_IsOK(ecode4)) {
28869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28870 }
28871 arg4 = static_cast< int >(val4);
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 (arg1)->Set(arg2,arg3,arg4);
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 resultobj = SWIG_Py_Void();
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28886 PyObject *resultobj = 0;
28887 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28888 int result;
28889 void *argp1 = 0 ;
28890 int res1 = 0 ;
28891 PyObject *swig_obj[1] ;
28892
28893 if (!args) SWIG_fail;
28894 swig_obj[0] = args;
28895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28896 if (!SWIG_IsOK(res1)) {
28897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28898 }
28899 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (int)(arg1)->GetFlags();
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_From_int(static_cast< int >(result));
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 PyObject *resultobj = 0;
28915 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28916 int result;
28917 void *argp1 = 0 ;
28918 int res1 = 0 ;
28919 PyObject *swig_obj[1] ;
28920
28921 if (!args) SWIG_fail;
28922 swig_obj[0] = args;
28923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28924 if (!SWIG_IsOK(res1)) {
28925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28926 }
28927 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (int)(arg1)->GetKeyCode();
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_From_int(static_cast< int >(result));
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28944 int result;
28945 void *argp1 = 0 ;
28946 int res1 = 0 ;
28947 PyObject *swig_obj[1] ;
28948
28949 if (!args) SWIG_fail;
28950 swig_obj[0] = args;
28951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28952 if (!SWIG_IsOK(res1)) {
28953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28954 }
28955 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (int)(arg1)->GetCommand();
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_From_int(static_cast< int >(result));
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
28974 }
28975
28976 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978 }
28979
28980 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 int arg1 ;
28983 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28984 wxAcceleratorTable *result = 0 ;
28985 PyObject * obj0 = 0 ;
28986 char * kwnames[] = {
28987 (char *) "n", NULL
28988 };
28989
28990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28991 {
28992 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28993 if (arg2) arg1 = PyList_Size(obj0);
28994 else arg1 = 0;
28995 }
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29010 PyObject *resultobj = 0;
29011 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 PyObject *swig_obj[1] ;
29015
29016 if (!args) SWIG_fail;
29017 swig_obj[0] = args;
29018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29019 if (!SWIG_IsOK(res1)) {
29020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29021 }
29022 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 delete arg1;
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_Py_Void();
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *resultobj = 0;
29039 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29040 bool result;
29041 void *argp1 = 0 ;
29042 int res1 = 0 ;
29043 PyObject *swig_obj[1] ;
29044
29045 if (!args) SWIG_fail;
29046 swig_obj[0] = args;
29047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29050 }
29051 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *obj;
29069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29070 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29071 return SWIG_Py_Void();
29072 }
29073
29074 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 return SWIG_Python_InitShadowInstance(args);
29076 }
29077
29078 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29079 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29080 return 1;
29081 }
29082
29083
29084 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29085 PyObject *pyobj = 0;
29086
29087 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29088 return pyobj;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj = 0;
29094 wxString *arg1 = 0 ;
29095 wxAcceleratorEntry *result = 0 ;
29096 bool temp1 = false ;
29097 PyObject * obj0 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "label", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29103 {
29104 arg1 = wxString_in_helper(obj0);
29105 if (arg1 == NULL) SWIG_fail;
29106 temp1 = true;
29107 }
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29115 {
29116 if (temp1)
29117 delete arg1;
29118 }
29119 return resultobj;
29120 fail:
29121 {
29122 if (temp1)
29123 delete arg1;
29124 }
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN int PanelNameStr_set(PyObject *) {
29130 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29131 return 1;
29132 }
29133
29134
29135 SWIGINTERN PyObject *PanelNameStr_get(void) {
29136 PyObject *pyobj = 0;
29137
29138 {
29139 #if wxUSE_UNICODE
29140 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29141 #else
29142 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29143 #endif
29144 }
29145 return pyobj;
29146 }
29147
29148
29149 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 PyObject *resultobj = 0;
29151 wxVisualAttributes *result = 0 ;
29152
29153 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 result = (wxVisualAttributes *)new_wxVisualAttributes();
29157 wxPyEndAllowThreads(__tstate);
29158 if (PyErr_Occurred()) SWIG_fail;
29159 }
29160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 PyObject *resultobj = 0;
29169 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29170 void *argp1 = 0 ;
29171 int res1 = 0 ;
29172 PyObject *swig_obj[1] ;
29173
29174 if (!args) SWIG_fail;
29175 swig_obj[0] = args;
29176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29179 }
29180 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 delete_wxVisualAttributes(arg1);
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_Py_Void();
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29198 wxFont *arg2 = (wxFont *) 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 void *argp2 = 0 ;
29202 int res2 = 0 ;
29203 PyObject *swig_obj[2] ;
29204
29205 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29207 if (!SWIG_IsOK(res1)) {
29208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29209 }
29210 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29211 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29212 if (!SWIG_IsOK(res2)) {
29213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29214 }
29215 arg2 = reinterpret_cast< wxFont * >(argp2);
29216 if (arg1) (arg1)->font = *arg2;
29217
29218 resultobj = SWIG_Py_Void();
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 PyObject *resultobj = 0;
29227 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29228 wxFont *result = 0 ;
29229 void *argp1 = 0 ;
29230 int res1 = 0 ;
29231 PyObject *swig_obj[1] ;
29232
29233 if (!args) SWIG_fail;
29234 swig_obj[0] = args;
29235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29236 if (!SWIG_IsOK(res1)) {
29237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29238 }
29239 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29240 result = (wxFont *)& ((arg1)->font);
29241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29249 PyObject *resultobj = 0;
29250 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29251 wxColour *arg2 = (wxColour *) 0 ;
29252 void *argp1 = 0 ;
29253 int res1 = 0 ;
29254 void *argp2 = 0 ;
29255 int res2 = 0 ;
29256 PyObject *swig_obj[2] ;
29257
29258 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29260 if (!SWIG_IsOK(res1)) {
29261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29262 }
29263 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29264 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29265 if (!SWIG_IsOK(res2)) {
29266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29267 }
29268 arg2 = reinterpret_cast< wxColour * >(argp2);
29269 if (arg1) (arg1)->colFg = *arg2;
29270
29271 resultobj = SWIG_Py_Void();
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29281 wxColour *result = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29291 }
29292 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29293 result = (wxColour *)& ((arg1)->colFg);
29294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29302 PyObject *resultobj = 0;
29303 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29304 wxColour *arg2 = (wxColour *) 0 ;
29305 void *argp1 = 0 ;
29306 int res1 = 0 ;
29307 void *argp2 = 0 ;
29308 int res2 = 0 ;
29309 PyObject *swig_obj[2] ;
29310
29311 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29313 if (!SWIG_IsOK(res1)) {
29314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29315 }
29316 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29317 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29318 if (!SWIG_IsOK(res2)) {
29319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29320 }
29321 arg2 = reinterpret_cast< wxColour * >(argp2);
29322 if (arg1) (arg1)->colBg = *arg2;
29323
29324 resultobj = SWIG_Py_Void();
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29332 PyObject *resultobj = 0;
29333 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29334 wxColour *result = 0 ;
29335 void *argp1 = 0 ;
29336 int res1 = 0 ;
29337 PyObject *swig_obj[1] ;
29338
29339 if (!args) SWIG_fail;
29340 swig_obj[0] = args;
29341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29344 }
29345 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29346 result = (wxColour *)& ((arg1)->colBg);
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 PyObject *obj;
29356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29357 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29358 return SWIG_Py_Void();
29359 }
29360
29361 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29362 return SWIG_Python_InitShadowInstance(args);
29363 }
29364
29365 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj = 0;
29367 wxWindow *arg1 = (wxWindow *) 0 ;
29368 int arg2 = (int) (int)-1 ;
29369 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29370 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29371 wxSize const &arg4_defvalue = wxDefaultSize ;
29372 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29373 long arg5 = (long) 0 ;
29374 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29375 wxString *arg6 = (wxString *) &arg6_defvalue ;
29376 wxWindow *result = 0 ;
29377 void *argp1 = 0 ;
29378 int res1 = 0 ;
29379 int val2 ;
29380 int ecode2 = 0 ;
29381 wxPoint temp3 ;
29382 wxSize temp4 ;
29383 long val5 ;
29384 int ecode5 = 0 ;
29385 bool temp6 = false ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 PyObject * obj2 = 0 ;
29389 PyObject * obj3 = 0 ;
29390 PyObject * obj4 = 0 ;
29391 PyObject * obj5 = 0 ;
29392 char * kwnames[] = {
29393 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29394 };
29395
29396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29400 }
29401 arg1 = reinterpret_cast< wxWindow * >(argp1);
29402 if (obj1) {
29403 ecode2 = SWIG_AsVal_int(obj1, &val2);
29404 if (!SWIG_IsOK(ecode2)) {
29405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29406 }
29407 arg2 = static_cast< int >(val2);
29408 }
29409 if (obj2) {
29410 {
29411 arg3 = &temp3;
29412 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29413 }
29414 }
29415 if (obj3) {
29416 {
29417 arg4 = &temp4;
29418 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29419 }
29420 }
29421 if (obj4) {
29422 ecode5 = SWIG_AsVal_long(obj4, &val5);
29423 if (!SWIG_IsOK(ecode5)) {
29424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29425 }
29426 arg5 = static_cast< long >(val5);
29427 }
29428 if (obj5) {
29429 {
29430 arg6 = wxString_in_helper(obj5);
29431 if (arg6 == NULL) SWIG_fail;
29432 temp6 = true;
29433 }
29434 }
29435 {
29436 if (!wxPyCheckForApp()) SWIG_fail;
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29443 {
29444 if (temp6)
29445 delete arg6;
29446 }
29447 return resultobj;
29448 fail:
29449 {
29450 if (temp6)
29451 delete arg6;
29452 }
29453 return NULL;
29454 }
29455
29456
29457 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29458 PyObject *resultobj = 0;
29459 wxWindow *result = 0 ;
29460
29461 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29462 {
29463 if (!wxPyCheckForApp()) SWIG_fail;
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxWindow *)new wxWindow();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 wxWindow *arg2 = (wxWindow *) 0 ;
29480 int arg3 = (int) (int)-1 ;
29481 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29482 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29483 wxSize const &arg5_defvalue = wxDefaultSize ;
29484 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29485 long arg6 = (long) 0 ;
29486 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29487 wxString *arg7 = (wxString *) &arg7_defvalue ;
29488 bool result;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 void *argp2 = 0 ;
29492 int res2 = 0 ;
29493 int val3 ;
29494 int ecode3 = 0 ;
29495 wxPoint temp4 ;
29496 wxSize temp5 ;
29497 long val6 ;
29498 int ecode6 = 0 ;
29499 bool temp7 = false ;
29500 PyObject * obj0 = 0 ;
29501 PyObject * obj1 = 0 ;
29502 PyObject * obj2 = 0 ;
29503 PyObject * obj3 = 0 ;
29504 PyObject * obj4 = 0 ;
29505 PyObject * obj5 = 0 ;
29506 PyObject * obj6 = 0 ;
29507 char * kwnames[] = {
29508 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29509 };
29510
29511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29513 if (!SWIG_IsOK(res1)) {
29514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29515 }
29516 arg1 = reinterpret_cast< wxWindow * >(argp1);
29517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29518 if (!SWIG_IsOK(res2)) {
29519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29520 }
29521 arg2 = reinterpret_cast< wxWindow * >(argp2);
29522 if (obj2) {
29523 ecode3 = SWIG_AsVal_int(obj2, &val3);
29524 if (!SWIG_IsOK(ecode3)) {
29525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29526 }
29527 arg3 = static_cast< int >(val3);
29528 }
29529 if (obj3) {
29530 {
29531 arg4 = &temp4;
29532 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29533 }
29534 }
29535 if (obj4) {
29536 {
29537 arg5 = &temp5;
29538 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29539 }
29540 }
29541 if (obj5) {
29542 ecode6 = SWIG_AsVal_long(obj5, &val6);
29543 if (!SWIG_IsOK(ecode6)) {
29544 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29545 }
29546 arg6 = static_cast< long >(val6);
29547 }
29548 if (obj6) {
29549 {
29550 arg7 = wxString_in_helper(obj6);
29551 if (arg7 == NULL) SWIG_fail;
29552 temp7 = true;
29553 }
29554 }
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 {
29562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29563 }
29564 {
29565 if (temp7)
29566 delete arg7;
29567 }
29568 return resultobj;
29569 fail:
29570 {
29571 if (temp7)
29572 delete arg7;
29573 }
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj = 0;
29580 wxWindow *arg1 = (wxWindow *) 0 ;
29581 bool arg2 = (bool) false ;
29582 bool result;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 bool val2 ;
29586 int ecode2 = 0 ;
29587 PyObject * obj0 = 0 ;
29588 PyObject * obj1 = 0 ;
29589 char * kwnames[] = {
29590 (char *) "self",(char *) "force", NULL
29591 };
29592
29593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29595 if (!SWIG_IsOK(res1)) {
29596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29597 }
29598 arg1 = reinterpret_cast< wxWindow * >(argp1);
29599 if (obj1) {
29600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29601 if (!SWIG_IsOK(ecode2)) {
29602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29603 }
29604 arg2 = static_cast< bool >(val2);
29605 }
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 result = (bool)(arg1)->Close(arg2);
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 {
29613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29614 }
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29622 PyObject *resultobj = 0;
29623 wxWindow *arg1 = (wxWindow *) 0 ;
29624 bool result;
29625 void *argp1 = 0 ;
29626 int res1 = 0 ;
29627 PyObject *swig_obj[1] ;
29628
29629 if (!args) SWIG_fail;
29630 swig_obj[0] = args;
29631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29634 }
29635 arg1 = reinterpret_cast< wxWindow * >(argp1);
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 result = (bool)(arg1)->Destroy();
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 {
29643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29644 }
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 wxWindow *arg1 = (wxWindow *) 0 ;
29654 bool result;
29655 void *argp1 = 0 ;
29656 int res1 = 0 ;
29657 PyObject *swig_obj[1] ;
29658
29659 if (!args) SWIG_fail;
29660 swig_obj[0] = args;
29661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29662 if (!SWIG_IsOK(res1)) {
29663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29664 }
29665 arg1 = reinterpret_cast< wxWindow * >(argp1);
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)(arg1)->DestroyChildren();
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 {
29673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29682 PyObject *resultobj = 0;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 bool result;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 PyObject *swig_obj[1] ;
29688
29689 if (!args) SWIG_fail;
29690 swig_obj[0] = args;
29691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29694 }
29695 arg1 = reinterpret_cast< wxWindow * >(argp1);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 {
29703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 wxString *arg2 = 0 ;
29715 void *argp1 = 0 ;
29716 int res1 = 0 ;
29717 bool temp2 = false ;
29718 PyObject * obj0 = 0 ;
29719 PyObject * obj1 = 0 ;
29720 char * kwnames[] = {
29721 (char *) "self",(char *) "label", NULL
29722 };
29723
29724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29726 if (!SWIG_IsOK(res1)) {
29727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29728 }
29729 arg1 = reinterpret_cast< wxWindow * >(argp1);
29730 {
29731 arg2 = wxString_in_helper(obj1);
29732 if (arg2 == NULL) SWIG_fail;
29733 temp2 = true;
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 (arg1)->SetLabel((wxString const &)*arg2);
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 resultobj = SWIG_Py_Void();
29742 {
29743 if (temp2)
29744 delete arg2;
29745 }
29746 return resultobj;
29747 fail:
29748 {
29749 if (temp2)
29750 delete arg2;
29751 }
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29757 PyObject *resultobj = 0;
29758 wxWindow *arg1 = (wxWindow *) 0 ;
29759 wxString result;
29760 void *argp1 = 0 ;
29761 int res1 = 0 ;
29762 PyObject *swig_obj[1] ;
29763
29764 if (!args) SWIG_fail;
29765 swig_obj[0] = args;
29766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29767 if (!SWIG_IsOK(res1)) {
29768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29769 }
29770 arg1 = reinterpret_cast< wxWindow * >(argp1);
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = ((wxWindow const *)arg1)->GetLabel();
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 {
29778 #if wxUSE_UNICODE
29779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29780 #else
29781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29782 #endif
29783 }
29784 return resultobj;
29785 fail:
29786 return NULL;
29787 }
29788
29789
29790 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29791 PyObject *resultobj = 0;
29792 wxWindow *arg1 = (wxWindow *) 0 ;
29793 wxString *arg2 = 0 ;
29794 void *argp1 = 0 ;
29795 int res1 = 0 ;
29796 bool temp2 = false ;
29797 PyObject * obj0 = 0 ;
29798 PyObject * obj1 = 0 ;
29799 char * kwnames[] = {
29800 (char *) "self",(char *) "name", NULL
29801 };
29802
29803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29807 }
29808 arg1 = reinterpret_cast< wxWindow * >(argp1);
29809 {
29810 arg2 = wxString_in_helper(obj1);
29811 if (arg2 == NULL) SWIG_fail;
29812 temp2 = true;
29813 }
29814 {
29815 PyThreadState* __tstate = wxPyBeginAllowThreads();
29816 (arg1)->SetName((wxString const &)*arg2);
29817 wxPyEndAllowThreads(__tstate);
29818 if (PyErr_Occurred()) SWIG_fail;
29819 }
29820 resultobj = SWIG_Py_Void();
29821 {
29822 if (temp2)
29823 delete arg2;
29824 }
29825 return resultobj;
29826 fail:
29827 {
29828 if (temp2)
29829 delete arg2;
29830 }
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29836 PyObject *resultobj = 0;
29837 wxWindow *arg1 = (wxWindow *) 0 ;
29838 wxString result;
29839 void *argp1 = 0 ;
29840 int res1 = 0 ;
29841 PyObject *swig_obj[1] ;
29842
29843 if (!args) SWIG_fail;
29844 swig_obj[0] = args;
29845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29848 }
29849 arg1 = reinterpret_cast< wxWindow * >(argp1);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = ((wxWindow const *)arg1)->GetName();
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 #if wxUSE_UNICODE
29858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29859 #else
29860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29861 #endif
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 wxWindowVariant arg2 ;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 int val2 ;
29876 int ecode2 = 0 ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 char * kwnames[] = {
29880 (char *) "self",(char *) "variant", NULL
29881 };
29882
29883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29887 }
29888 arg1 = reinterpret_cast< wxWindow * >(argp1);
29889 ecode2 = SWIG_AsVal_int(obj1, &val2);
29890 if (!SWIG_IsOK(ecode2)) {
29891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29892 }
29893 arg2 = static_cast< wxWindowVariant >(val2);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->SetWindowVariant(arg2);
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_Py_Void();
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 wxWindow *arg1 = (wxWindow *) 0 ;
29910 wxWindowVariant result;
29911 void *argp1 = 0 ;
29912 int res1 = 0 ;
29913 PyObject *swig_obj[1] ;
29914
29915 if (!args) SWIG_fail;
29916 swig_obj[0] = args;
29917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29918 if (!SWIG_IsOK(res1)) {
29919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29920 }
29921 arg1 = reinterpret_cast< wxWindow * >(argp1);
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 resultobj = SWIG_From_int(static_cast< int >(result));
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj = 0;
29937 wxWindow *arg1 = (wxWindow *) 0 ;
29938 int arg2 ;
29939 void *argp1 = 0 ;
29940 int res1 = 0 ;
29941 int val2 ;
29942 int ecode2 = 0 ;
29943 PyObject * obj0 = 0 ;
29944 PyObject * obj1 = 0 ;
29945 char * kwnames[] = {
29946 (char *) "self",(char *) "winid", NULL
29947 };
29948
29949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29951 if (!SWIG_IsOK(res1)) {
29952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29953 }
29954 arg1 = reinterpret_cast< wxWindow * >(argp1);
29955 ecode2 = SWIG_AsVal_int(obj1, &val2);
29956 if (!SWIG_IsOK(ecode2)) {
29957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29958 }
29959 arg2 = static_cast< int >(val2);
29960 {
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 (arg1)->SetId(arg2);
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 resultobj = SWIG_Py_Void();
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxWindow *arg1 = (wxWindow *) 0 ;
29976 int result;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29986 }
29987 arg1 = reinterpret_cast< wxWindow * >(argp1);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (int)((wxWindow const *)arg1)->GetId();
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 resultobj = SWIG_From_int(static_cast< int >(result));
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30002 PyObject *resultobj = 0;
30003 int result;
30004
30005 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30006 {
30007 PyThreadState* __tstate = wxPyBeginAllowThreads();
30008 result = (int)wxWindow::NewControlId();
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 resultobj = SWIG_From_int(static_cast< int >(result));
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 int arg1 ;
30022 int result;
30023 int val1 ;
30024 int ecode1 = 0 ;
30025 PyObject * obj0 = 0 ;
30026 char * kwnames[] = {
30027 (char *) "winid", NULL
30028 };
30029
30030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30031 ecode1 = SWIG_AsVal_int(obj0, &val1);
30032 if (!SWIG_IsOK(ecode1)) {
30033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30034 }
30035 arg1 = static_cast< int >(val1);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (int)wxWindow::NextControlId(arg1);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_From_int(static_cast< int >(result));
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj = 0;
30051 int arg1 ;
30052 int result;
30053 int val1 ;
30054 int ecode1 = 0 ;
30055 PyObject * obj0 = 0 ;
30056 char * kwnames[] = {
30057 (char *) "winid", NULL
30058 };
30059
30060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30061 ecode1 = SWIG_AsVal_int(obj0, &val1);
30062 if (!SWIG_IsOK(ecode1)) {
30063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30064 }
30065 arg1 = static_cast< int >(val1);
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (int)wxWindow::PrevControlId(arg1);
30069 wxPyEndAllowThreads(__tstate);
30070 if (PyErr_Occurred()) SWIG_fail;
30071 }
30072 resultobj = SWIG_From_int(static_cast< int >(result));
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj = 0;
30081 wxWindow *arg1 = (wxWindow *) 0 ;
30082 wxSize *arg2 = 0 ;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 wxSize temp2 ;
30086 PyObject * obj0 = 0 ;
30087 PyObject * obj1 = 0 ;
30088 char * kwnames[] = {
30089 (char *) "self",(char *) "size", NULL
30090 };
30091
30092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30096 }
30097 arg1 = reinterpret_cast< wxWindow * >(argp1);
30098 {
30099 arg2 = &temp2;
30100 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30101 }
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 (arg1)->SetSize((wxSize const &)*arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_Py_Void();
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30116 PyObject *resultobj = 0;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 int arg2 ;
30119 int arg3 ;
30120 int arg4 ;
30121 int arg5 ;
30122 int arg6 = (int) wxSIZE_AUTO ;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 int val2 ;
30126 int ecode2 = 0 ;
30127 int val3 ;
30128 int ecode3 = 0 ;
30129 int val4 ;
30130 int ecode4 = 0 ;
30131 int val5 ;
30132 int ecode5 = 0 ;
30133 int val6 ;
30134 int ecode6 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 PyObject * obj2 = 0 ;
30138 PyObject * obj3 = 0 ;
30139 PyObject * obj4 = 0 ;
30140 PyObject * obj5 = 0 ;
30141 char * kwnames[] = {
30142 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30143 };
30144
30145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30147 if (!SWIG_IsOK(res1)) {
30148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30149 }
30150 arg1 = reinterpret_cast< wxWindow * >(argp1);
30151 ecode2 = SWIG_AsVal_int(obj1, &val2);
30152 if (!SWIG_IsOK(ecode2)) {
30153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30154 }
30155 arg2 = static_cast< int >(val2);
30156 ecode3 = SWIG_AsVal_int(obj2, &val3);
30157 if (!SWIG_IsOK(ecode3)) {
30158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30159 }
30160 arg3 = static_cast< int >(val3);
30161 ecode4 = SWIG_AsVal_int(obj3, &val4);
30162 if (!SWIG_IsOK(ecode4)) {
30163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30164 }
30165 arg4 = static_cast< int >(val4);
30166 ecode5 = SWIG_AsVal_int(obj4, &val5);
30167 if (!SWIG_IsOK(ecode5)) {
30168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30169 }
30170 arg5 = static_cast< int >(val5);
30171 if (obj5) {
30172 ecode6 = SWIG_AsVal_int(obj5, &val6);
30173 if (!SWIG_IsOK(ecode6)) {
30174 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30175 }
30176 arg6 = static_cast< int >(val6);
30177 }
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_Py_Void();
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxRect *arg2 = 0 ;
30195 int arg3 = (int) wxSIZE_AUTO ;
30196 void *argp1 = 0 ;
30197 int res1 = 0 ;
30198 wxRect temp2 ;
30199 int val3 ;
30200 int ecode3 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 PyObject * obj2 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30212 }
30213 arg1 = reinterpret_cast< wxWindow * >(argp1);
30214 {
30215 arg2 = &temp2;
30216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30217 }
30218 if (obj2) {
30219 ecode3 = SWIG_AsVal_int(obj2, &val3);
30220 if (!SWIG_IsOK(ecode3)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30222 }
30223 arg3 = static_cast< int >(val3);
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_Py_Void();
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj = 0;
30240 wxWindow *arg1 = (wxWindow *) 0 ;
30241 int arg2 ;
30242 int arg3 ;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 int val2 ;
30246 int ecode2 = 0 ;
30247 int val3 ;
30248 int ecode3 = 0 ;
30249 PyObject * obj0 = 0 ;
30250 PyObject * obj1 = 0 ;
30251 PyObject * obj2 = 0 ;
30252 char * kwnames[] = {
30253 (char *) "self",(char *) "width",(char *) "height", NULL
30254 };
30255
30256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30260 }
30261 arg1 = reinterpret_cast< wxWindow * >(argp1);
30262 ecode2 = SWIG_AsVal_int(obj1, &val2);
30263 if (!SWIG_IsOK(ecode2)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30265 }
30266 arg2 = static_cast< int >(val2);
30267 ecode3 = SWIG_AsVal_int(obj2, &val3);
30268 if (!SWIG_IsOK(ecode3)) {
30269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30270 }
30271 arg3 = static_cast< int >(val3);
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 (arg1)->SetSize(arg2,arg3);
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 resultobj = SWIG_Py_Void();
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj = 0;
30287 wxWindow *arg1 = (wxWindow *) 0 ;
30288 wxPoint *arg2 = 0 ;
30289 int arg3 = (int) wxSIZE_USE_EXISTING ;
30290 void *argp1 = 0 ;
30291 int res1 = 0 ;
30292 wxPoint temp2 ;
30293 int val3 ;
30294 int ecode3 = 0 ;
30295 PyObject * obj0 = 0 ;
30296 PyObject * obj1 = 0 ;
30297 PyObject * obj2 = 0 ;
30298 char * kwnames[] = {
30299 (char *) "self",(char *) "pt",(char *) "flags", NULL
30300 };
30301
30302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 {
30309 arg2 = &temp2;
30310 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30311 }
30312 if (obj2) {
30313 ecode3 = SWIG_AsVal_int(obj2, &val3);
30314 if (!SWIG_IsOK(ecode3)) {
30315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30316 }
30317 arg3 = static_cast< int >(val3);
30318 }
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 (arg1)->Move((wxPoint const &)*arg2,arg3);
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 resultobj = SWIG_Py_Void();
30326 return resultobj;
30327 fail:
30328 return NULL;
30329 }
30330
30331
30332 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30333 PyObject *resultobj = 0;
30334 wxWindow *arg1 = (wxWindow *) 0 ;
30335 int arg2 ;
30336 int arg3 ;
30337 int arg4 = (int) wxSIZE_USE_EXISTING ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 int val2 ;
30341 int ecode2 = 0 ;
30342 int val3 ;
30343 int ecode3 = 0 ;
30344 int val4 ;
30345 int ecode4 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 PyObject * obj2 = 0 ;
30349 PyObject * obj3 = 0 ;
30350 char * kwnames[] = {
30351 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30352 };
30353
30354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30356 if (!SWIG_IsOK(res1)) {
30357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30358 }
30359 arg1 = reinterpret_cast< wxWindow * >(argp1);
30360 ecode2 = SWIG_AsVal_int(obj1, &val2);
30361 if (!SWIG_IsOK(ecode2)) {
30362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30363 }
30364 arg2 = static_cast< int >(val2);
30365 ecode3 = SWIG_AsVal_int(obj2, &val3);
30366 if (!SWIG_IsOK(ecode3)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30368 }
30369 arg3 = static_cast< int >(val3);
30370 if (obj3) {
30371 ecode4 = SWIG_AsVal_int(obj3, &val4);
30372 if (!SWIG_IsOK(ecode4)) {
30373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30374 }
30375 arg4 = static_cast< int >(val4);
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->Move(arg2,arg3,arg4);
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj = 0;
30392 wxWindow *arg1 = (wxWindow *) 0 ;
30393 wxSize const &arg2_defvalue = wxDefaultSize ;
30394 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
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 *)"O|O:Window_SetBestFittingSize",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_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30408 }
30409 arg1 = reinterpret_cast< wxWindow * >(argp1);
30410 if (obj1) {
30411 {
30412 arg2 = &temp2;
30413 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30414 }
30415 }
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30430 PyObject *resultobj = 0;
30431 wxWindow *arg1 = (wxWindow *) 0 ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 PyObject *swig_obj[1] ;
30435
30436 if (!args) SWIG_fail;
30437 swig_obj[0] = args;
30438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30439 if (!SWIG_IsOK(res1)) {
30440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30441 }
30442 arg1 = reinterpret_cast< wxWindow * >(argp1);
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 (arg1)->Raise();
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 resultobj = SWIG_Py_Void();
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30457 PyObject *resultobj = 0;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 void *argp1 = 0 ;
30460 int res1 = 0 ;
30461 PyObject *swig_obj[1] ;
30462
30463 if (!args) SWIG_fail;
30464 swig_obj[0] = args;
30465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30466 if (!SWIG_IsOK(res1)) {
30467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30468 }
30469 arg1 = reinterpret_cast< wxWindow * >(argp1);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 (arg1)->Lower();
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_Py_Void();
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30484 PyObject *resultobj = 0;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 wxSize *arg2 = 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 wxSize temp2 ;
30490 PyObject * obj0 = 0 ;
30491 PyObject * obj1 = 0 ;
30492 char * kwnames[] = {
30493 (char *) "self",(char *) "size", NULL
30494 };
30495
30496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30500 }
30501 arg1 = reinterpret_cast< wxWindow * >(argp1);
30502 {
30503 arg2 = &temp2;
30504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30505 }
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 (arg1)->SetClientSize((wxSize const &)*arg2);
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_Py_Void();
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30520 PyObject *resultobj = 0;
30521 wxWindow *arg1 = (wxWindow *) 0 ;
30522 int arg2 ;
30523 int arg3 ;
30524 void *argp1 = 0 ;
30525 int res1 = 0 ;
30526 int val2 ;
30527 int ecode2 = 0 ;
30528 int val3 ;
30529 int ecode3 = 0 ;
30530 PyObject * obj0 = 0 ;
30531 PyObject * obj1 = 0 ;
30532 PyObject * obj2 = 0 ;
30533 char * kwnames[] = {
30534 (char *) "self",(char *) "width",(char *) "height", NULL
30535 };
30536
30537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30541 }
30542 arg1 = reinterpret_cast< wxWindow * >(argp1);
30543 ecode2 = SWIG_AsVal_int(obj1, &val2);
30544 if (!SWIG_IsOK(ecode2)) {
30545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30546 }
30547 arg2 = static_cast< int >(val2);
30548 ecode3 = SWIG_AsVal_int(obj2, &val3);
30549 if (!SWIG_IsOK(ecode3)) {
30550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30551 }
30552 arg3 = static_cast< int >(val3);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 (arg1)->SetClientSize(arg2,arg3);
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_Py_Void();
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30567 PyObject *resultobj = 0;
30568 wxWindow *arg1 = (wxWindow *) 0 ;
30569 wxRect *arg2 = 0 ;
30570 void *argp1 = 0 ;
30571 int res1 = 0 ;
30572 wxRect temp2 ;
30573 PyObject * obj0 = 0 ;
30574 PyObject * obj1 = 0 ;
30575 char * kwnames[] = {
30576 (char *) "self",(char *) "rect", NULL
30577 };
30578
30579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30581 if (!SWIG_IsOK(res1)) {
30582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30583 }
30584 arg1 = reinterpret_cast< wxWindow * >(argp1);
30585 {
30586 arg2 = &temp2;
30587 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30588 }
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 (arg1)->SetClientSize((wxRect const &)*arg2);
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 resultobj = SWIG_Py_Void();
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30603 PyObject *resultobj = 0;
30604 wxWindow *arg1 = (wxWindow *) 0 ;
30605 wxPoint result;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 PyObject *swig_obj[1] ;
30609
30610 if (!args) SWIG_fail;
30611 swig_obj[0] = args;
30612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30615 }
30616 arg1 = reinterpret_cast< wxWindow * >(argp1);
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = ((wxWindow const *)arg1)->GetPosition();
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30631 PyObject *resultobj = 0;
30632 wxWindow *arg1 = (wxWindow *) 0 ;
30633 int *arg2 = (int *) 0 ;
30634 int *arg3 = (int *) 0 ;
30635 void *argp1 = 0 ;
30636 int res1 = 0 ;
30637 int temp2 ;
30638 int res2 = SWIG_TMPOBJ ;
30639 int temp3 ;
30640 int res3 = SWIG_TMPOBJ ;
30641 PyObject *swig_obj[1] ;
30642
30643 arg2 = &temp2;
30644 arg3 = &temp3;
30645 if (!args) SWIG_fail;
30646 swig_obj[0] = args;
30647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30650 }
30651 arg1 = reinterpret_cast< wxWindow * >(argp1);
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 resultobj = SWIG_Py_Void();
30659 if (SWIG_IsTmpObj(res2)) {
30660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30661 } else {
30662 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30664 }
30665 if (SWIG_IsTmpObj(res3)) {
30666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30667 } else {
30668 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30670 }
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxPoint result;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 PyObject *swig_obj[1] ;
30684
30685 if (!args) SWIG_fail;
30686 swig_obj[0] = args;
30687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = ((wxWindow const *)arg1)->GetScreenPosition();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 int *arg2 = (int *) 0 ;
30709 int *arg3 = (int *) 0 ;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 int temp2 ;
30713 int res2 = SWIG_TMPOBJ ;
30714 int temp3 ;
30715 int res3 = SWIG_TMPOBJ ;
30716 PyObject *swig_obj[1] ;
30717
30718 arg2 = &temp2;
30719 arg3 = &temp3;
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30725 }
30726 arg1 = reinterpret_cast< wxWindow * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_Py_Void();
30734 if (SWIG_IsTmpObj(res2)) {
30735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30736 } else {
30737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30739 }
30740 if (SWIG_IsTmpObj(res3)) {
30741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30742 } else {
30743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30745 }
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 wxRect result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxWindow * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = ((wxWindow const *)arg1)->GetScreenRect();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxSize result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxWindow * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = ((wxWindow const *)arg1)->GetSize();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxWindow *arg1 = (wxWindow *) 0 ;
30811 int *arg2 = (int *) 0 ;
30812 int *arg3 = (int *) 0 ;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 int temp2 ;
30816 int res2 = SWIG_TMPOBJ ;
30817 int temp3 ;
30818 int res3 = SWIG_TMPOBJ ;
30819 PyObject *swig_obj[1] ;
30820
30821 arg2 = &temp2;
30822 arg3 = &temp3;
30823 if (!args) SWIG_fail;
30824 swig_obj[0] = args;
30825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30828 }
30829 arg1 = reinterpret_cast< wxWindow * >(argp1);
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 resultobj = SWIG_Py_Void();
30837 if (SWIG_IsTmpObj(res2)) {
30838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30839 } else {
30840 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30842 }
30843 if (SWIG_IsTmpObj(res3)) {
30844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30845 } else {
30846 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 wxRect result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxWindow * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = ((wxWindow const *)arg1)->GetRect();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30884 PyObject *resultobj = 0;
30885 wxWindow *arg1 = (wxWindow *) 0 ;
30886 wxSize result;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 PyObject *swig_obj[1] ;
30890
30891 if (!args) SWIG_fail;
30892 swig_obj[0] = args;
30893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30894 if (!SWIG_IsOK(res1)) {
30895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30896 }
30897 arg1 = reinterpret_cast< wxWindow * >(argp1);
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = ((wxWindow const *)arg1)->GetClientSize();
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30912 PyObject *resultobj = 0;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 int *arg2 = (int *) 0 ;
30915 int *arg3 = (int *) 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 int temp2 ;
30919 int res2 = SWIG_TMPOBJ ;
30920 int temp3 ;
30921 int res3 = SWIG_TMPOBJ ;
30922 PyObject *swig_obj[1] ;
30923
30924 arg2 = &temp2;
30925 arg3 = &temp3;
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = SWIG_Py_Void();
30940 if (SWIG_IsTmpObj(res2)) {
30941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30942 } else {
30943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30945 }
30946 if (SWIG_IsTmpObj(res3)) {
30947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30948 } else {
30949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30951 }
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30959 PyObject *resultobj = 0;
30960 wxWindow *arg1 = (wxWindow *) 0 ;
30961 wxPoint result;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 PyObject *swig_obj[1] ;
30965
30966 if (!args) SWIG_fail;
30967 swig_obj[0] = args;
30968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30971 }
30972 arg1 = reinterpret_cast< wxWindow * >(argp1);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxWindow *arg1 = (wxWindow *) 0 ;
30989 wxRect result;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30999 }
31000 arg1 = reinterpret_cast< wxWindow * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = ((wxWindow const *)arg1)->GetClientRect();
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxSize result;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 PyObject *swig_obj[1] ;
31021
31022 if (!args) SWIG_fail;
31023 swig_obj[0] = args;
31024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31027 }
31028 arg1 = reinterpret_cast< wxWindow * >(argp1);
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = ((wxWindow const *)arg1)->GetBestSize();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 int *arg2 = (int *) 0 ;
31046 int *arg3 = (int *) 0 ;
31047 void *argp1 = 0 ;
31048 int res1 = 0 ;
31049 int temp2 ;
31050 int res2 = SWIG_TMPOBJ ;
31051 int temp3 ;
31052 int res3 = SWIG_TMPOBJ ;
31053 PyObject *swig_obj[1] ;
31054
31055 arg2 = &temp2;
31056 arg3 = &temp3;
31057 if (!args) SWIG_fail;
31058 swig_obj[0] = args;
31059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31060 if (!SWIG_IsOK(res1)) {
31061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31062 }
31063 arg1 = reinterpret_cast< wxWindow * >(argp1);
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 resultobj = SWIG_Py_Void();
31071 if (SWIG_IsTmpObj(res2)) {
31072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31073 } else {
31074 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31076 }
31077 if (SWIG_IsTmpObj(res3)) {
31078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31079 } else {
31080 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31082 }
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxWindow *arg1 = (wxWindow *) 0 ;
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_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 (arg1)->InvalidateBestSize();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_Py_Void();
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSize *arg2 = 0 ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 wxSize temp2 ;
31123 PyObject * obj0 = 0 ;
31124 PyObject * obj1 = 0 ;
31125 char * kwnames[] = {
31126 (char *) "self",(char *) "size", NULL
31127 };
31128
31129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31133 }
31134 arg1 = reinterpret_cast< wxWindow * >(argp1);
31135 {
31136 arg2 = &temp2;
31137 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31138 }
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 resultobj = SWIG_Py_Void();
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31153 PyObject *resultobj = 0;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxSize result;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 PyObject *swig_obj[1] ;
31159
31160 if (!args) SWIG_fail;
31161 swig_obj[0] = args;
31162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31163 if (!SWIG_IsOK(res1)) {
31164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31165 }
31166 arg1 = reinterpret_cast< wxWindow * >(argp1);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31181 PyObject *resultobj = 0;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 wxSize result;
31184 void *argp1 = 0 ;
31185 int res1 = 0 ;
31186 PyObject *swig_obj[1] ;
31187
31188 if (!args) SWIG_fail;
31189 swig_obj[0] = args;
31190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31191 if (!SWIG_IsOK(res1)) {
31192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31193 }
31194 arg1 = reinterpret_cast< wxWindow * >(argp1);
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj = 0;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 int arg2 = (int) wxBOTH ;
31212 void *argp1 = 0 ;
31213 int res1 = 0 ;
31214 int val2 ;
31215 int ecode2 = 0 ;
31216 PyObject * obj0 = 0 ;
31217 PyObject * obj1 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "self",(char *) "direction", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31224 if (!SWIG_IsOK(res1)) {
31225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31226 }
31227 arg1 = reinterpret_cast< wxWindow * >(argp1);
31228 if (obj1) {
31229 ecode2 = SWIG_AsVal_int(obj1, &val2);
31230 if (!SWIG_IsOK(ecode2)) {
31231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31232 }
31233 arg2 = static_cast< int >(val2);
31234 }
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->Center(arg2);
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 int arg2 = (int) wxBOTH ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 int val2 ;
31255 int ecode2 = 0 ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 char * kwnames[] = {
31259 (char *) "self",(char *) "dir", NULL
31260 };
31261
31262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31266 }
31267 arg1 = reinterpret_cast< wxWindow * >(argp1);
31268 if (obj1) {
31269 ecode2 = SWIG_AsVal_int(obj1, &val2);
31270 if (!SWIG_IsOK(ecode2)) {
31271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31272 }
31273 arg2 = static_cast< int >(val2);
31274 }
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 (arg1)->CenterOnParent(arg2);
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_Py_Void();
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 PyObject *resultobj = 0;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 void *argp1 = 0 ;
31292 int res1 = 0 ;
31293 PyObject *swig_obj[1] ;
31294
31295 if (!args) SWIG_fail;
31296 swig_obj[0] = args;
31297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31298 if (!SWIG_IsOK(res1)) {
31299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31300 }
31301 arg1 = reinterpret_cast< wxWindow * >(argp1);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 (arg1)->Fit();
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31316 PyObject *resultobj = 0;
31317 wxWindow *arg1 = (wxWindow *) 0 ;
31318 void *argp1 = 0 ;
31319 int res1 = 0 ;
31320 PyObject *swig_obj[1] ;
31321
31322 if (!args) SWIG_fail;
31323 swig_obj[0] = args;
31324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31325 if (!SWIG_IsOK(res1)) {
31326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31327 }
31328 arg1 = reinterpret_cast< wxWindow * >(argp1);
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 (arg1)->FitInside();
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_Py_Void();
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj = 0;
31344 wxWindow *arg1 = (wxWindow *) 0 ;
31345 int arg2 ;
31346 int arg3 ;
31347 int arg4 = (int) -1 ;
31348 int arg5 = (int) -1 ;
31349 int arg6 = (int) -1 ;
31350 int arg7 = (int) -1 ;
31351 void *argp1 = 0 ;
31352 int res1 = 0 ;
31353 int val2 ;
31354 int ecode2 = 0 ;
31355 int val3 ;
31356 int ecode3 = 0 ;
31357 int val4 ;
31358 int ecode4 = 0 ;
31359 int val5 ;
31360 int ecode5 = 0 ;
31361 int val6 ;
31362 int ecode6 = 0 ;
31363 int val7 ;
31364 int ecode7 = 0 ;
31365 PyObject * obj0 = 0 ;
31366 PyObject * obj1 = 0 ;
31367 PyObject * obj2 = 0 ;
31368 PyObject * obj3 = 0 ;
31369 PyObject * obj4 = 0 ;
31370 PyObject * obj5 = 0 ;
31371 PyObject * obj6 = 0 ;
31372 char * kwnames[] = {
31373 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31374 };
31375
31376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31380 }
31381 arg1 = reinterpret_cast< wxWindow * >(argp1);
31382 ecode2 = SWIG_AsVal_int(obj1, &val2);
31383 if (!SWIG_IsOK(ecode2)) {
31384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31385 }
31386 arg2 = static_cast< int >(val2);
31387 ecode3 = SWIG_AsVal_int(obj2, &val3);
31388 if (!SWIG_IsOK(ecode3)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31390 }
31391 arg3 = static_cast< int >(val3);
31392 if (obj3) {
31393 ecode4 = SWIG_AsVal_int(obj3, &val4);
31394 if (!SWIG_IsOK(ecode4)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31396 }
31397 arg4 = static_cast< int >(val4);
31398 }
31399 if (obj4) {
31400 ecode5 = SWIG_AsVal_int(obj4, &val5);
31401 if (!SWIG_IsOK(ecode5)) {
31402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31403 }
31404 arg5 = static_cast< int >(val5);
31405 }
31406 if (obj5) {
31407 ecode6 = SWIG_AsVal_int(obj5, &val6);
31408 if (!SWIG_IsOK(ecode6)) {
31409 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31410 }
31411 arg6 = static_cast< int >(val6);
31412 }
31413 if (obj6) {
31414 ecode7 = SWIG_AsVal_int(obj6, &val7);
31415 if (!SWIG_IsOK(ecode7)) {
31416 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31417 }
31418 arg7 = static_cast< int >(val7);
31419 }
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 resultobj = SWIG_Py_Void();
31427 return resultobj;
31428 fail:
31429 return NULL;
31430 }
31431
31432
31433 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31434 PyObject *resultobj = 0;
31435 wxWindow *arg1 = (wxWindow *) 0 ;
31436 wxSize *arg2 = 0 ;
31437 wxSize const &arg3_defvalue = wxDefaultSize ;
31438 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31439 wxSize const &arg4_defvalue = wxDefaultSize ;
31440 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 wxSize temp2 ;
31444 wxSize temp3 ;
31445 wxSize temp4 ;
31446 PyObject * obj0 = 0 ;
31447 PyObject * obj1 = 0 ;
31448 PyObject * obj2 = 0 ;
31449 PyObject * obj3 = 0 ;
31450 char * kwnames[] = {
31451 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31452 };
31453
31454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31456 if (!SWIG_IsOK(res1)) {
31457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31458 }
31459 arg1 = reinterpret_cast< wxWindow * >(argp1);
31460 {
31461 arg2 = &temp2;
31462 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31463 }
31464 if (obj2) {
31465 {
31466 arg3 = &temp3;
31467 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31468 }
31469 }
31470 if (obj3) {
31471 {
31472 arg4 = &temp4;
31473 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31474 }
31475 }
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj = 0;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 int arg2 ;
31493 int arg3 ;
31494 int arg4 = (int) -1 ;
31495 int arg5 = (int) -1 ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 int val2 ;
31499 int ecode2 = 0 ;
31500 int val3 ;
31501 int ecode3 = 0 ;
31502 int val4 ;
31503 int ecode4 = 0 ;
31504 int val5 ;
31505 int ecode5 = 0 ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 PyObject * obj2 = 0 ;
31509 PyObject * obj3 = 0 ;
31510 PyObject * obj4 = 0 ;
31511 char * kwnames[] = {
31512 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31513 };
31514
31515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31517 if (!SWIG_IsOK(res1)) {
31518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31519 }
31520 arg1 = reinterpret_cast< wxWindow * >(argp1);
31521 ecode2 = SWIG_AsVal_int(obj1, &val2);
31522 if (!SWIG_IsOK(ecode2)) {
31523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31524 }
31525 arg2 = static_cast< int >(val2);
31526 ecode3 = SWIG_AsVal_int(obj2, &val3);
31527 if (!SWIG_IsOK(ecode3)) {
31528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31529 }
31530 arg3 = static_cast< int >(val3);
31531 if (obj3) {
31532 ecode4 = SWIG_AsVal_int(obj3, &val4);
31533 if (!SWIG_IsOK(ecode4)) {
31534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31535 }
31536 arg4 = static_cast< int >(val4);
31537 }
31538 if (obj4) {
31539 ecode5 = SWIG_AsVal_int(obj4, &val5);
31540 if (!SWIG_IsOK(ecode5)) {
31541 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31542 }
31543 arg5 = static_cast< int >(val5);
31544 }
31545 {
31546 PyThreadState* __tstate = wxPyBeginAllowThreads();
31547 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 resultobj = SWIG_Py_Void();
31552 return resultobj;
31553 fail:
31554 return NULL;
31555 }
31556
31557
31558 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31559 PyObject *resultobj = 0;
31560 wxWindow *arg1 = (wxWindow *) 0 ;
31561 wxSize *arg2 = 0 ;
31562 wxSize const &arg3_defvalue = wxDefaultSize ;
31563 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31564 void *argp1 = 0 ;
31565 int res1 = 0 ;
31566 wxSize temp2 ;
31567 wxSize temp3 ;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 PyObject * obj2 = 0 ;
31571 char * kwnames[] = {
31572 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31573 };
31574
31575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31579 }
31580 arg1 = reinterpret_cast< wxWindow * >(argp1);
31581 {
31582 arg2 = &temp2;
31583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31584 }
31585 if (obj2) {
31586 {
31587 arg3 = &temp3;
31588 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31589 }
31590 }
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
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_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605 PyObject *resultobj = 0;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 wxSize result;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 result = ((wxWindow const *)arg1)->GetMaxSize();
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 wxSize result;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 PyObject *swig_obj[1] ;
31639
31640 if (!args) SWIG_fail;
31641 swig_obj[0] = args;
31642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31643 if (!SWIG_IsOK(res1)) {
31644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31645 }
31646 arg1 = reinterpret_cast< wxWindow * >(argp1);
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 result = ((wxWindow const *)arg1)->GetMinSize();
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31661 PyObject *resultobj = 0;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 wxSize *arg2 = 0 ;
31664 void *argp1 = 0 ;
31665 int res1 = 0 ;
31666 wxSize temp2 ;
31667 PyObject * obj0 = 0 ;
31668 PyObject * obj1 = 0 ;
31669 char * kwnames[] = {
31670 (char *) "self",(char *) "minSize", NULL
31671 };
31672
31673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31677 }
31678 arg1 = reinterpret_cast< wxWindow * >(argp1);
31679 {
31680 arg2 = &temp2;
31681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 (arg1)->SetMinSize((wxSize const &)*arg2);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31697 PyObject *resultobj = 0;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 wxSize *arg2 = 0 ;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 wxSize temp2 ;
31703 PyObject * obj0 = 0 ;
31704 PyObject * obj1 = 0 ;
31705 char * kwnames[] = {
31706 (char *) "self",(char *) "maxSize", NULL
31707 };
31708
31709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31711 if (!SWIG_IsOK(res1)) {
31712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31713 }
31714 arg1 = reinterpret_cast< wxWindow * >(argp1);
31715 {
31716 arg2 = &temp2;
31717 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31718 }
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 (arg1)->SetMaxSize((wxSize const &)*arg2);
31722 wxPyEndAllowThreads(__tstate);
31723 if (PyErr_Occurred()) SWIG_fail;
31724 }
31725 resultobj = SWIG_Py_Void();
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 int result;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject *swig_obj[1] ;
31739
31740 if (!args) SWIG_fail;
31741 swig_obj[0] = args;
31742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31745 }
31746 arg1 = reinterpret_cast< wxWindow * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_From_int(static_cast< int >(result));
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 int result;
31764 void *argp1 = 0 ;
31765 int res1 = 0 ;
31766 PyObject *swig_obj[1] ;
31767
31768 if (!args) SWIG_fail;
31769 swig_obj[0] = args;
31770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31773 }
31774 arg1 = reinterpret_cast< wxWindow * >(argp1);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_From_int(static_cast< int >(result));
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxWindow * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_From_int(static_cast< int >(result));
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxWindow * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_From_int(static_cast< int >(result));
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 wxSize *arg2 = 0 ;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 wxSize temp2 ;
31851 PyObject * obj0 = 0 ;
31852 PyObject * obj1 = 0 ;
31853 char * kwnames[] = {
31854 (char *) "self",(char *) "size", NULL
31855 };
31856
31857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31859 if (!SWIG_IsOK(res1)) {
31860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31861 }
31862 arg1 = reinterpret_cast< wxWindow * >(argp1);
31863 {
31864 arg2 = &temp2;
31865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31866 }
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 int arg2 ;
31884 int arg3 ;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 int val2 ;
31888 int ecode2 = 0 ;
31889 int val3 ;
31890 int ecode3 = 0 ;
31891 PyObject * obj0 = 0 ;
31892 PyObject * obj1 = 0 ;
31893 PyObject * obj2 = 0 ;
31894 char * kwnames[] = {
31895 (char *) "self",(char *) "w",(char *) "h", NULL
31896 };
31897
31898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31902 }
31903 arg1 = reinterpret_cast< wxWindow * >(argp1);
31904 ecode2 = SWIG_AsVal_int(obj1, &val2);
31905 if (!SWIG_IsOK(ecode2)) {
31906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31907 }
31908 arg2 = static_cast< int >(val2);
31909 ecode3 = SWIG_AsVal_int(obj2, &val3);
31910 if (!SWIG_IsOK(ecode3)) {
31911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31912 }
31913 arg3 = static_cast< int >(val3);
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 (arg1)->SetVirtualSize(arg2,arg3);
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 resultobj = SWIG_Py_Void();
31921 return resultobj;
31922 fail:
31923 return NULL;
31924 }
31925
31926
31927 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31928 PyObject *resultobj = 0;
31929 wxWindow *arg1 = (wxWindow *) 0 ;
31930 wxSize result;
31931 void *argp1 = 0 ;
31932 int res1 = 0 ;
31933 PyObject *swig_obj[1] ;
31934
31935 if (!args) SWIG_fail;
31936 swig_obj[0] = args;
31937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31938 if (!SWIG_IsOK(res1)) {
31939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31940 }
31941 arg1 = reinterpret_cast< wxWindow * >(argp1);
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 result = ((wxWindow const *)arg1)->GetVirtualSize();
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 PyObject *resultobj = 0;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 int *arg2 = (int *) 0 ;
31959 int *arg3 = (int *) 0 ;
31960 void *argp1 = 0 ;
31961 int res1 = 0 ;
31962 int temp2 ;
31963 int res2 = SWIG_TMPOBJ ;
31964 int temp3 ;
31965 int res3 = SWIG_TMPOBJ ;
31966 PyObject *swig_obj[1] ;
31967
31968 arg2 = &temp2;
31969 arg3 = &temp3;
31970 if (!args) SWIG_fail;
31971 swig_obj[0] = args;
31972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31973 if (!SWIG_IsOK(res1)) {
31974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31975 }
31976 arg1 = reinterpret_cast< wxWindow * >(argp1);
31977 {
31978 PyThreadState* __tstate = wxPyBeginAllowThreads();
31979 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31980 wxPyEndAllowThreads(__tstate);
31981 if (PyErr_Occurred()) SWIG_fail;
31982 }
31983 resultobj = SWIG_Py_Void();
31984 if (SWIG_IsTmpObj(res2)) {
31985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31986 } else {
31987 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31989 }
31990 if (SWIG_IsTmpObj(res3)) {
31991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31992 } else {
31993 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31995 }
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32003 PyObject *resultobj = 0;
32004 wxWindow *arg1 = (wxWindow *) 0 ;
32005 wxSize result;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32031 PyObject *resultobj = 0;
32032 wxWindow *arg1 = (wxWindow *) 0 ;
32033 bool arg2 = (bool) true ;
32034 bool result;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 bool val2 ;
32038 int ecode2 = 0 ;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 char * kwnames[] = {
32042 (char *) "self",(char *) "show", NULL
32043 };
32044
32045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 if (obj1) {
32052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32053 if (!SWIG_IsOK(ecode2)) {
32054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32055 }
32056 arg2 = static_cast< bool >(val2);
32057 }
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 result = (bool)(arg1)->Show(arg2);
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 {
32065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32066 }
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32074 PyObject *resultobj = 0;
32075 wxWindow *arg1 = (wxWindow *) 0 ;
32076 bool result;
32077 void *argp1 = 0 ;
32078 int res1 = 0 ;
32079 PyObject *swig_obj[1] ;
32080
32081 if (!args) SWIG_fail;
32082 swig_obj[0] = args;
32083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32084 if (!SWIG_IsOK(res1)) {
32085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32086 }
32087 arg1 = reinterpret_cast< wxWindow * >(argp1);
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 result = (bool)(arg1)->Hide();
32091 wxPyEndAllowThreads(__tstate);
32092 if (PyErr_Occurred()) SWIG_fail;
32093 }
32094 {
32095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32096 }
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj = 0;
32105 wxWindow *arg1 = (wxWindow *) 0 ;
32106 bool arg2 = (bool) true ;
32107 bool result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 bool val2 ;
32111 int ecode2 = 0 ;
32112 PyObject * obj0 = 0 ;
32113 PyObject * obj1 = 0 ;
32114 char * kwnames[] = {
32115 (char *) "self",(char *) "enable", NULL
32116 };
32117
32118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32120 if (!SWIG_IsOK(res1)) {
32121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32122 }
32123 arg1 = reinterpret_cast< wxWindow * >(argp1);
32124 if (obj1) {
32125 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32126 if (!SWIG_IsOK(ecode2)) {
32127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32128 }
32129 arg2 = static_cast< bool >(val2);
32130 }
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (bool)(arg1)->Enable(arg2);
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 {
32138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32139 }
32140 return resultobj;
32141 fail:
32142 return NULL;
32143 }
32144
32145
32146 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32147 PyObject *resultobj = 0;
32148 wxWindow *arg1 = (wxWindow *) 0 ;
32149 bool result;
32150 void *argp1 = 0 ;
32151 int res1 = 0 ;
32152 PyObject *swig_obj[1] ;
32153
32154 if (!args) SWIG_fail;
32155 swig_obj[0] = args;
32156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32159 }
32160 arg1 = reinterpret_cast< wxWindow * >(argp1);
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (bool)(arg1)->Disable();
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 {
32168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32169 }
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxWindow *arg1 = (wxWindow *) 0 ;
32179 bool result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32189 }
32190 arg1 = reinterpret_cast< wxWindow * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (bool)((wxWindow const *)arg1)->IsShown();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 bool result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 {
32228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32229 }
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxWindow *arg1 = (wxWindow *) 0 ;
32239 long arg2 ;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 long val2 ;
32243 int ecode2 = 0 ;
32244 PyObject * obj0 = 0 ;
32245 PyObject * obj1 = 0 ;
32246 char * kwnames[] = {
32247 (char *) "self",(char *) "style", NULL
32248 };
32249
32250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32252 if (!SWIG_IsOK(res1)) {
32253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32254 }
32255 arg1 = reinterpret_cast< wxWindow * >(argp1);
32256 ecode2 = SWIG_AsVal_long(obj1, &val2);
32257 if (!SWIG_IsOK(ecode2)) {
32258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32259 }
32260 arg2 = static_cast< long >(val2);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 (arg1)->SetWindowStyleFlag(arg2);
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 resultobj = SWIG_Py_Void();
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *resultobj = 0;
32276 wxWindow *arg1 = (wxWindow *) 0 ;
32277 long result;
32278 void *argp1 = 0 ;
32279 int res1 = 0 ;
32280 PyObject *swig_obj[1] ;
32281
32282 if (!args) SWIG_fail;
32283 swig_obj[0] = args;
32284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32285 if (!SWIG_IsOK(res1)) {
32286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32287 }
32288 arg1 = reinterpret_cast< wxWindow * >(argp1);
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_From_long(static_cast< long >(result));
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj = 0;
32304 wxWindow *arg1 = (wxWindow *) 0 ;
32305 int arg2 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 int val2 ;
32310 int ecode2 = 0 ;
32311 PyObject * obj0 = 0 ;
32312 PyObject * obj1 = 0 ;
32313 char * kwnames[] = {
32314 (char *) "self",(char *) "flag", NULL
32315 };
32316
32317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32319 if (!SWIG_IsOK(res1)) {
32320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32321 }
32322 arg1 = reinterpret_cast< wxWindow * >(argp1);
32323 ecode2 = SWIG_AsVal_int(obj1, &val2);
32324 if (!SWIG_IsOK(ecode2)) {
32325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32326 }
32327 arg2 = static_cast< int >(val2);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 {
32335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32336 }
32337 return resultobj;
32338 fail:
32339 return NULL;
32340 }
32341
32342
32343 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344 PyObject *resultobj = 0;
32345 wxWindow *arg1 = (wxWindow *) 0 ;
32346 bool result;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 PyObject *swig_obj[1] ;
32350
32351 if (!args) SWIG_fail;
32352 swig_obj[0] = args;
32353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32356 }
32357 arg1 = reinterpret_cast< wxWindow * >(argp1);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (bool)((wxWindow const *)arg1)->IsRetained();
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 {
32365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32366 }
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32374 PyObject *resultobj = 0;
32375 wxWindow *arg1 = (wxWindow *) 0 ;
32376 long arg2 ;
32377 void *argp1 = 0 ;
32378 int res1 = 0 ;
32379 long val2 ;
32380 int ecode2 = 0 ;
32381 PyObject * obj0 = 0 ;
32382 PyObject * obj1 = 0 ;
32383 char * kwnames[] = {
32384 (char *) "self",(char *) "exStyle", NULL
32385 };
32386
32387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32391 }
32392 arg1 = reinterpret_cast< wxWindow * >(argp1);
32393 ecode2 = SWIG_AsVal_long(obj1, &val2);
32394 if (!SWIG_IsOK(ecode2)) {
32395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32396 }
32397 arg2 = static_cast< long >(val2);
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 (arg1)->SetExtraStyle(arg2);
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_Py_Void();
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32412 PyObject *resultobj = 0;
32413 wxWindow *arg1 = (wxWindow *) 0 ;
32414 long result;
32415 void *argp1 = 0 ;
32416 int res1 = 0 ;
32417 PyObject *swig_obj[1] ;
32418
32419 if (!args) SWIG_fail;
32420 swig_obj[0] = args;
32421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32422 if (!SWIG_IsOK(res1)) {
32423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32424 }
32425 arg1 = reinterpret_cast< wxWindow * >(argp1);
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 resultobj = SWIG_From_long(static_cast< long >(result));
32433 return resultobj;
32434 fail:
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32440 PyObject *resultobj = 0;
32441 wxWindow *arg1 = (wxWindow *) 0 ;
32442 bool arg2 = (bool) true ;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 bool val2 ;
32446 int ecode2 = 0 ;
32447 PyObject * obj0 = 0 ;
32448 PyObject * obj1 = 0 ;
32449 char * kwnames[] = {
32450 (char *) "self",(char *) "modal", NULL
32451 };
32452
32453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32455 if (!SWIG_IsOK(res1)) {
32456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32457 }
32458 arg1 = reinterpret_cast< wxWindow * >(argp1);
32459 if (obj1) {
32460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32461 if (!SWIG_IsOK(ecode2)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32463 }
32464 arg2 = static_cast< bool >(val2);
32465 }
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 (arg1)->MakeModal(arg2);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_Py_Void();
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32480 PyObject *resultobj = 0;
32481 wxWindow *arg1 = (wxWindow *) 0 ;
32482 bool arg2 ;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 bool val2 ;
32486 int ecode2 = 0 ;
32487 PyObject * obj0 = 0 ;
32488 PyObject * obj1 = 0 ;
32489 char * kwnames[] = {
32490 (char *) "self",(char *) "enableTheme", NULL
32491 };
32492
32493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32497 }
32498 arg1 = reinterpret_cast< wxWindow * >(argp1);
32499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32500 if (!SWIG_IsOK(ecode2)) {
32501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32502 }
32503 arg2 = static_cast< bool >(val2);
32504 {
32505 PyThreadState* __tstate = wxPyBeginAllowThreads();
32506 (arg1)->SetThemeEnabled(arg2);
32507 wxPyEndAllowThreads(__tstate);
32508 if (PyErr_Occurred()) SWIG_fail;
32509 }
32510 resultobj = SWIG_Py_Void();
32511 return resultobj;
32512 fail:
32513 return NULL;
32514 }
32515
32516
32517 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32518 PyObject *resultobj = 0;
32519 wxWindow *arg1 = (wxWindow *) 0 ;
32520 bool result;
32521 void *argp1 = 0 ;
32522 int res1 = 0 ;
32523 PyObject *swig_obj[1] ;
32524
32525 if (!args) SWIG_fail;
32526 swig_obj[0] = args;
32527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32530 }
32531 arg1 = reinterpret_cast< wxWindow * >(argp1);
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32540 }
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxWindow *arg1 = (wxWindow *) 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 (arg1)->SetFocus();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_Py_Void();
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxWindow *arg1 = (wxWindow *) 0 ;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 (arg1)->SetFocusFromKbd();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_Py_Void();
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 PyObject *resultobj = 0;
32603 wxWindow *result = 0 ;
32604
32605 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32606 {
32607 if (!wxPyCheckForApp()) SWIG_fail;
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (wxWindow *)wxWindow::FindFocus();
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = wxPyMake_wxObject(result, 0);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *resultobj = 0;
32624 wxWindow *arg1 = (wxWindow *) 0 ;
32625 bool result;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 PyObject *swig_obj[1] ;
32629
32630 if (!args) SWIG_fail;
32631 swig_obj[0] = args;
32632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32635 }
32636 arg1 = reinterpret_cast< wxWindow * >(argp1);
32637 {
32638 PyThreadState* __tstate = wxPyBeginAllowThreads();
32639 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32640 wxPyEndAllowThreads(__tstate);
32641 if (PyErr_Occurred()) SWIG_fail;
32642 }
32643 {
32644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32645 }
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxWindow *arg1 = (wxWindow *) 0 ;
32655 bool result;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32665 }
32666 arg1 = reinterpret_cast< wxWindow * >(argp1);
32667 {
32668 PyThreadState* __tstate = wxPyBeginAllowThreads();
32669 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32670 wxPyEndAllowThreads(__tstate);
32671 if (PyErr_Occurred()) SWIG_fail;
32672 }
32673 {
32674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32675 }
32676 return resultobj;
32677 fail:
32678 return NULL;
32679 }
32680
32681
32682 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 PyObject *resultobj = 0;
32684 wxWindow *arg1 = (wxWindow *) 0 ;
32685 wxWindow *result = 0 ;
32686 void *argp1 = 0 ;
32687 int res1 = 0 ;
32688 PyObject *swig_obj[1] ;
32689
32690 if (!args) SWIG_fail;
32691 swig_obj[0] = args;
32692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32695 }
32696 arg1 = reinterpret_cast< wxWindow * >(argp1);
32697 {
32698 PyThreadState* __tstate = wxPyBeginAllowThreads();
32699 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32700 wxPyEndAllowThreads(__tstate);
32701 if (PyErr_Occurred()) SWIG_fail;
32702 }
32703 {
32704 resultobj = wxPyMake_wxObject(result, 0);
32705 }
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32713 PyObject *resultobj = 0;
32714 wxWindow *arg1 = (wxWindow *) 0 ;
32715 wxWindow *arg2 = (wxWindow *) 0 ;
32716 wxWindow *result = 0 ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 void *argp2 = 0 ;
32720 int res2 = 0 ;
32721 PyObject * obj0 = 0 ;
32722 PyObject * obj1 = 0 ;
32723 char * kwnames[] = {
32724 (char *) "self",(char *) "child", NULL
32725 };
32726
32727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32729 if (!SWIG_IsOK(res1)) {
32730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32731 }
32732 arg1 = reinterpret_cast< wxWindow * >(argp1);
32733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32734 if (!SWIG_IsOK(res2)) {
32735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32736 }
32737 arg2 = reinterpret_cast< wxWindow * >(argp2);
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 {
32745 resultobj = wxPyMake_wxObject(result, 0);
32746 }
32747 return resultobj;
32748 fail:
32749 return NULL;
32750 }
32751
32752
32753 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj = 0;
32755 wxWindow *arg1 = (wxWindow *) 0 ;
32756 wxWindow *arg2 = (wxWindow *) 0 ;
32757 void *argp1 = 0 ;
32758 int res1 = 0 ;
32759 void *argp2 = 0 ;
32760 int res2 = 0 ;
32761 PyObject * obj0 = 0 ;
32762 PyObject * obj1 = 0 ;
32763 char * kwnames[] = {
32764 (char *) "self",(char *) "win", NULL
32765 };
32766
32767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32771 }
32772 arg1 = reinterpret_cast< wxWindow * >(argp1);
32773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32774 if (!SWIG_IsOK(res2)) {
32775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32776 }
32777 arg2 = reinterpret_cast< wxWindow * >(argp2);
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 (arg1)->SetTmpDefaultItem(arg2);
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 resultobj = SWIG_Py_Void();
32785 return resultobj;
32786 fail:
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32792 PyObject *resultobj = 0;
32793 wxWindow *arg1 = (wxWindow *) 0 ;
32794 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32795 bool result;
32796 void *argp1 = 0 ;
32797 int res1 = 0 ;
32798 int val2 ;
32799 int ecode2 = 0 ;
32800 PyObject * obj0 = 0 ;
32801 PyObject * obj1 = 0 ;
32802 char * kwnames[] = {
32803 (char *) "self",(char *) "flags", NULL
32804 };
32805
32806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32808 if (!SWIG_IsOK(res1)) {
32809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32810 }
32811 arg1 = reinterpret_cast< wxWindow * >(argp1);
32812 if (obj1) {
32813 ecode2 = SWIG_AsVal_int(obj1, &val2);
32814 if (!SWIG_IsOK(ecode2)) {
32815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32816 }
32817 arg2 = static_cast< int >(val2);
32818 }
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 result = (bool)(arg1)->Navigate(arg2);
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32827 }
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj = 0;
32836 wxWindow *arg1 = (wxWindow *) 0 ;
32837 wxWindow *arg2 = (wxWindow *) 0 ;
32838 void *argp1 = 0 ;
32839 int res1 = 0 ;
32840 void *argp2 = 0 ;
32841 int res2 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 char * kwnames[] = {
32845 (char *) "self",(char *) "win", NULL
32846 };
32847
32848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res2)) {
32856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32857 }
32858 arg2 = reinterpret_cast< wxWindow * >(argp2);
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 (arg1)->MoveAfterInTabOrder(arg2);
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 resultobj = SWIG_Py_Void();
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = 0;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 wxWindow *arg2 = (wxWindow *) 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 void *argp2 = 0 ;
32879 int res2 = 0 ;
32880 PyObject * obj0 = 0 ;
32881 PyObject * obj1 = 0 ;
32882 char * kwnames[] = {
32883 (char *) "self",(char *) "win", NULL
32884 };
32885
32886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res1)) {
32889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32890 }
32891 arg1 = reinterpret_cast< wxWindow * >(argp1);
32892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res2)) {
32894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32895 }
32896 arg2 = reinterpret_cast< wxWindow * >(argp2);
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 (arg1)->MoveBeforeInTabOrder(arg2);
32900 wxPyEndAllowThreads(__tstate);
32901 if (PyErr_Occurred()) SWIG_fail;
32902 }
32903 resultobj = SWIG_Py_Void();
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 PyObject *result = 0 ;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 PyObject *swig_obj[1] ;
32917
32918 if (!args) SWIG_fail;
32919 swig_obj[0] = args;
32920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32921 if (!SWIG_IsOK(res1)) {
32922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32923 }
32924 arg1 = reinterpret_cast< wxWindow * >(argp1);
32925 {
32926 PyThreadState* __tstate = wxPyBeginAllowThreads();
32927 result = (PyObject *)wxWindow_GetChildren(arg1);
32928 wxPyEndAllowThreads(__tstate);
32929 if (PyErr_Occurred()) SWIG_fail;
32930 }
32931 resultobj = result;
32932 return resultobj;
32933 fail:
32934 return NULL;
32935 }
32936
32937
32938 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32939 PyObject *resultobj = 0;
32940 wxWindow *arg1 = (wxWindow *) 0 ;
32941 wxWindow *result = 0 ;
32942 void *argp1 = 0 ;
32943 int res1 = 0 ;
32944 PyObject *swig_obj[1] ;
32945
32946 if (!args) SWIG_fail;
32947 swig_obj[0] = args;
32948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res1)) {
32950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32951 }
32952 arg1 = reinterpret_cast< wxWindow * >(argp1);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 {
32960 resultobj = wxPyMake_wxObject(result, 0);
32961 }
32962 return resultobj;
32963 fail:
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32969 PyObject *resultobj = 0;
32970 wxWindow *arg1 = (wxWindow *) 0 ;
32971 wxWindow *result = 0 ;
32972 void *argp1 = 0 ;
32973 int res1 = 0 ;
32974 PyObject *swig_obj[1] ;
32975
32976 if (!args) SWIG_fail;
32977 swig_obj[0] = args;
32978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res1)) {
32980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32981 }
32982 arg1 = reinterpret_cast< wxWindow * >(argp1);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 {
32990 resultobj = wxPyMake_wxObject(result, 0);
32991 }
32992 return resultobj;
32993 fail:
32994 return NULL;
32995 }
32996
32997
32998 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32999 PyObject *resultobj = 0;
33000 wxWindow *arg1 = (wxWindow *) 0 ;
33001 bool result;
33002 void *argp1 = 0 ;
33003 int res1 = 0 ;
33004 PyObject *swig_obj[1] ;
33005
33006 if (!args) SWIG_fail;
33007 swig_obj[0] = args;
33008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33009 if (!SWIG_IsOK(res1)) {
33010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33011 }
33012 arg1 = reinterpret_cast< wxWindow * >(argp1);
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 {
33020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33021 }
33022 return resultobj;
33023 fail:
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33029 PyObject *resultobj = 0;
33030 wxWindow *arg1 = (wxWindow *) 0 ;
33031 wxWindow *arg2 = (wxWindow *) 0 ;
33032 bool result;
33033 void *argp1 = 0 ;
33034 int res1 = 0 ;
33035 void *argp2 = 0 ;
33036 int res2 = 0 ;
33037 PyObject * obj0 = 0 ;
33038 PyObject * obj1 = 0 ;
33039 char * kwnames[] = {
33040 (char *) "self",(char *) "newParent", NULL
33041 };
33042
33043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33050 if (!SWIG_IsOK(res2)) {
33051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33052 }
33053 arg2 = reinterpret_cast< wxWindow * >(argp2);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = (bool)(arg1)->Reparent(arg2);
33057 wxPyEndAllowThreads(__tstate);
33058 if (PyErr_Occurred()) SWIG_fail;
33059 }
33060 {
33061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33062 }
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33070 PyObject *resultobj = 0;
33071 wxWindow *arg1 = (wxWindow *) 0 ;
33072 wxWindow *arg2 = (wxWindow *) 0 ;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 void *argp2 = 0 ;
33076 int res2 = 0 ;
33077 PyObject * obj0 = 0 ;
33078 PyObject * obj1 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "self",(char *) "child", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33085 if (!SWIG_IsOK(res1)) {
33086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33087 }
33088 arg1 = reinterpret_cast< wxWindow * >(argp1);
33089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33090 if (!SWIG_IsOK(res2)) {
33091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33092 }
33093 arg2 = reinterpret_cast< wxWindow * >(argp2);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 (arg1)->AddChild(arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_Py_Void();
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 wxWindow *arg2 = (wxWindow *) 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 void *argp2 = 0 ;
33114 int res2 = 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char * kwnames[] = {
33118 (char *) "self",(char *) "child", NULL
33119 };
33120
33121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33128 if (!SWIG_IsOK(res2)) {
33129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33130 }
33131 arg2 = reinterpret_cast< wxWindow * >(argp2);
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 (arg1)->RemoveChild(arg2);
33135 wxPyEndAllowThreads(__tstate);
33136 if (PyErr_Occurred()) SWIG_fail;
33137 }
33138 resultobj = SWIG_Py_Void();
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj = 0;
33147 wxWindow *arg1 = (wxWindow *) 0 ;
33148 long arg2 ;
33149 wxWindow *result = 0 ;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 long val2 ;
33153 int ecode2 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char * kwnames[] = {
33157 (char *) "self",(char *) "winid", NULL
33158 };
33159
33160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 ecode2 = SWIG_AsVal_long(obj1, &val2);
33167 if (!SWIG_IsOK(ecode2)) {
33168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33169 }
33170 arg2 = static_cast< long >(val2);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (wxWindow *)(arg1)->FindWindow(arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 resultobj = wxPyMake_wxObject(result, 0);
33179 }
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxWindow *arg1 = (wxWindow *) 0 ;
33189 wxString *arg2 = 0 ;
33190 wxWindow *result = 0 ;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 bool temp2 = false ;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 char * kwnames[] = {
33197 (char *) "self",(char *) "name", NULL
33198 };
33199
33200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33204 }
33205 arg1 = reinterpret_cast< wxWindow * >(argp1);
33206 {
33207 arg2 = wxString_in_helper(obj1);
33208 if (arg2 == NULL) SWIG_fail;
33209 temp2 = true;
33210 }
33211 {
33212 PyThreadState* __tstate = wxPyBeginAllowThreads();
33213 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 {
33218 resultobj = wxPyMake_wxObject(result, 0);
33219 }
33220 {
33221 if (temp2)
33222 delete arg2;
33223 }
33224 return resultobj;
33225 fail:
33226 {
33227 if (temp2)
33228 delete arg2;
33229 }
33230 return NULL;
33231 }
33232
33233
33234 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33235 PyObject *resultobj = 0;
33236 wxWindow *arg1 = (wxWindow *) 0 ;
33237 wxEvtHandler *result = 0 ;
33238 void *argp1 = 0 ;
33239 int res1 = 0 ;
33240 PyObject *swig_obj[1] ;
33241
33242 if (!args) SWIG_fail;
33243 swig_obj[0] = args;
33244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33247 }
33248 arg1 = reinterpret_cast< wxWindow * >(argp1);
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33252 wxPyEndAllowThreads(__tstate);
33253 if (PyErr_Occurred()) SWIG_fail;
33254 }
33255 {
33256 resultobj = wxPyMake_wxObject(result, 0);
33257 }
33258 return resultobj;
33259 fail:
33260 return NULL;
33261 }
33262
33263
33264 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj = 0;
33266 wxWindow *arg1 = (wxWindow *) 0 ;
33267 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33268 void *argp1 = 0 ;
33269 int res1 = 0 ;
33270 void *argp2 = 0 ;
33271 int res2 = 0 ;
33272 PyObject * obj0 = 0 ;
33273 PyObject * obj1 = 0 ;
33274 char * kwnames[] = {
33275 (char *) "self",(char *) "handler", NULL
33276 };
33277
33278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33280 if (!SWIG_IsOK(res1)) {
33281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33282 }
33283 arg1 = reinterpret_cast< wxWindow * >(argp1);
33284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33285 if (!SWIG_IsOK(res2)) {
33286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33287 }
33288 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 (arg1)->SetEventHandler(arg2);
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 resultobj = SWIG_Py_Void();
33296 return resultobj;
33297 fail:
33298 return NULL;
33299 }
33300
33301
33302 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33303 PyObject *resultobj = 0;
33304 wxWindow *arg1 = (wxWindow *) 0 ;
33305 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33306 void *argp1 = 0 ;
33307 int res1 = 0 ;
33308 void *argp2 = 0 ;
33309 int res2 = 0 ;
33310 PyObject * obj0 = 0 ;
33311 PyObject * obj1 = 0 ;
33312 char * kwnames[] = {
33313 (char *) "self",(char *) "handler", NULL
33314 };
33315
33316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33318 if (!SWIG_IsOK(res1)) {
33319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33320 }
33321 arg1 = reinterpret_cast< wxWindow * >(argp1);
33322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33323 if (!SWIG_IsOK(res2)) {
33324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33325 }
33326 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 (arg1)->PushEventHandler(arg2);
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_Py_Void();
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 wxWindow *arg1 = (wxWindow *) 0 ;
33343 bool arg2 = (bool) false ;
33344 wxEvtHandler *result = 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 bool val2 ;
33348 int ecode2 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char * kwnames[] = {
33352 (char *) "self",(char *) "deleteHandler", NULL
33353 };
33354
33355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 if (obj1) {
33362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33363 if (!SWIG_IsOK(ecode2)) {
33364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33365 }
33366 arg2 = static_cast< bool >(val2);
33367 }
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33371 wxPyEndAllowThreads(__tstate);
33372 if (PyErr_Occurred()) SWIG_fail;
33373 }
33374 {
33375 resultobj = wxPyMake_wxObject(result, 0);
33376 }
33377 return resultobj;
33378 fail:
33379 return NULL;
33380 }
33381
33382
33383 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33384 PyObject *resultobj = 0;
33385 wxWindow *arg1 = (wxWindow *) 0 ;
33386 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33387 bool result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 void *argp2 = 0 ;
33391 int res2 = 0 ;
33392 PyObject * obj0 = 0 ;
33393 PyObject * obj1 = 0 ;
33394 char * kwnames[] = {
33395 (char *) "self",(char *) "handler", NULL
33396 };
33397
33398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33400 if (!SWIG_IsOK(res1)) {
33401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33402 }
33403 arg1 = reinterpret_cast< wxWindow * >(argp1);
33404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33405 if (!SWIG_IsOK(res2)) {
33406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33407 }
33408 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (bool)(arg1)->RemoveEventHandler(arg2);
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 {
33416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33417 }
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj = 0;
33426 wxWindow *arg1 = (wxWindow *) 0 ;
33427 wxValidator *arg2 = 0 ;
33428 void *argp1 = 0 ;
33429 int res1 = 0 ;
33430 void *argp2 = 0 ;
33431 int res2 = 0 ;
33432 PyObject * obj0 = 0 ;
33433 PyObject * obj1 = 0 ;
33434 char * kwnames[] = {
33435 (char *) "self",(char *) "validator", NULL
33436 };
33437
33438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33440 if (!SWIG_IsOK(res1)) {
33441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33442 }
33443 arg1 = reinterpret_cast< wxWindow * >(argp1);
33444 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33445 if (!SWIG_IsOK(res2)) {
33446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33447 }
33448 if (!argp2) {
33449 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33450 }
33451 arg2 = reinterpret_cast< wxValidator * >(argp2);
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 (arg1)->SetValidator((wxValidator const &)*arg2);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_Py_Void();
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33466 PyObject *resultobj = 0;
33467 wxWindow *arg1 = (wxWindow *) 0 ;
33468 wxValidator *result = 0 ;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 PyObject *swig_obj[1] ;
33472
33473 if (!args) SWIG_fail;
33474 swig_obj[0] = args;
33475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33478 }
33479 arg1 = reinterpret_cast< wxWindow * >(argp1);
33480 {
33481 PyThreadState* __tstate = wxPyBeginAllowThreads();
33482 result = (wxValidator *)(arg1)->GetValidator();
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 {
33487 resultobj = wxPyMake_wxObject(result, (bool)0);
33488 }
33489 return resultobj;
33490 fail:
33491 return NULL;
33492 }
33493
33494
33495 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33496 PyObject *resultobj = 0;
33497 wxWindow *arg1 = (wxWindow *) 0 ;
33498 bool result;
33499 void *argp1 = 0 ;
33500 int res1 = 0 ;
33501 PyObject *swig_obj[1] ;
33502
33503 if (!args) SWIG_fail;
33504 swig_obj[0] = args;
33505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33506 if (!SWIG_IsOK(res1)) {
33507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33508 }
33509 arg1 = reinterpret_cast< wxWindow * >(argp1);
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (bool)(arg1)->Validate();
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 {
33517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33518 }
33519 return resultobj;
33520 fail:
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33526 PyObject *resultobj = 0;
33527 wxWindow *arg1 = (wxWindow *) 0 ;
33528 bool result;
33529 void *argp1 = 0 ;
33530 int res1 = 0 ;
33531 PyObject *swig_obj[1] ;
33532
33533 if (!args) SWIG_fail;
33534 swig_obj[0] = args;
33535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (bool)(arg1)->TransferDataToWindow();
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 {
33547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33548 }
33549 return resultobj;
33550 fail:
33551 return NULL;
33552 }
33553
33554
33555 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 PyObject *resultobj = 0;
33557 wxWindow *arg1 = (wxWindow *) 0 ;
33558 bool result;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 PyObject *swig_obj[1] ;
33562
33563 if (!args) SWIG_fail;
33564 swig_obj[0] = args;
33565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33566 if (!SWIG_IsOK(res1)) {
33567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33568 }
33569 arg1 = reinterpret_cast< wxWindow * >(argp1);
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 result = (bool)(arg1)->TransferDataFromWindow();
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 {
33577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33578 }
33579 return resultobj;
33580 fail:
33581 return NULL;
33582 }
33583
33584
33585 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 PyObject *resultobj = 0;
33587 wxWindow *arg1 = (wxWindow *) 0 ;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 (arg1)->InitDialog();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 resultobj = SWIG_Py_Void();
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj = 0;
33614 wxWindow *arg1 = (wxWindow *) 0 ;
33615 wxAcceleratorTable *arg2 = 0 ;
33616 void *argp1 = 0 ;
33617 int res1 = 0 ;
33618 void *argp2 = 0 ;
33619 int res2 = 0 ;
33620 PyObject * obj0 = 0 ;
33621 PyObject * obj1 = 0 ;
33622 char * kwnames[] = {
33623 (char *) "self",(char *) "accel", NULL
33624 };
33625
33626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33630 }
33631 arg1 = reinterpret_cast< wxWindow * >(argp1);
33632 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33633 if (!SWIG_IsOK(res2)) {
33634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33635 }
33636 if (!argp2) {
33637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33638 }
33639 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33640 {
33641 PyThreadState* __tstate = wxPyBeginAllowThreads();
33642 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 resultobj = SWIG_Py_Void();
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33654 PyObject *resultobj = 0;
33655 wxWindow *arg1 = (wxWindow *) 0 ;
33656 wxAcceleratorTable *result = 0 ;
33657 void *argp1 = 0 ;
33658 int res1 = 0 ;
33659 PyObject *swig_obj[1] ;
33660
33661 if (!args) SWIG_fail;
33662 swig_obj[0] = args;
33663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33666 }
33667 arg1 = reinterpret_cast< wxWindow * >(argp1);
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33675 return resultobj;
33676 fail:
33677 return NULL;
33678 }
33679
33680
33681 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj = 0;
33683 wxWindow *arg1 = (wxWindow *) 0 ;
33684 int arg2 ;
33685 int arg3 ;
33686 int arg4 ;
33687 bool result;
33688 void *argp1 = 0 ;
33689 int res1 = 0 ;
33690 int val2 ;
33691 int ecode2 = 0 ;
33692 int val3 ;
33693 int ecode3 = 0 ;
33694 int val4 ;
33695 int ecode4 = 0 ;
33696 PyObject * obj0 = 0 ;
33697 PyObject * obj1 = 0 ;
33698 PyObject * obj2 = 0 ;
33699 PyObject * obj3 = 0 ;
33700 char * kwnames[] = {
33701 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33702 };
33703
33704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33708 }
33709 arg1 = reinterpret_cast< wxWindow * >(argp1);
33710 ecode2 = SWIG_AsVal_int(obj1, &val2);
33711 if (!SWIG_IsOK(ecode2)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33713 }
33714 arg2 = static_cast< int >(val2);
33715 ecode3 = SWIG_AsVal_int(obj2, &val3);
33716 if (!SWIG_IsOK(ecode3)) {
33717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33718 }
33719 arg3 = static_cast< int >(val3);
33720 ecode4 = SWIG_AsVal_int(obj3, &val4);
33721 if (!SWIG_IsOK(ecode4)) {
33722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33723 }
33724 arg4 = static_cast< int >(val4);
33725 {
33726 PyThreadState* __tstate = wxPyBeginAllowThreads();
33727 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33728 wxPyEndAllowThreads(__tstate);
33729 if (PyErr_Occurred()) SWIG_fail;
33730 }
33731 {
33732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33733 }
33734 return resultobj;
33735 fail:
33736 return NULL;
33737 }
33738
33739
33740 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33741 PyObject *resultobj = 0;
33742 wxWindow *arg1 = (wxWindow *) 0 ;
33743 int arg2 ;
33744 bool result;
33745 void *argp1 = 0 ;
33746 int res1 = 0 ;
33747 int val2 ;
33748 int ecode2 = 0 ;
33749 PyObject * obj0 = 0 ;
33750 PyObject * obj1 = 0 ;
33751 char * kwnames[] = {
33752 (char *) "self",(char *) "hotkeyId", NULL
33753 };
33754
33755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 ecode2 = SWIG_AsVal_int(obj1, &val2);
33762 if (!SWIG_IsOK(ecode2)) {
33763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33764 }
33765 arg2 = static_cast< int >(val2);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33774 }
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj = 0;
33783 wxWindow *arg1 = (wxWindow *) 0 ;
33784 wxPoint *arg2 = 0 ;
33785 wxPoint result;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 wxPoint temp2 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 char * kwnames[] = {
33792 (char *) "self",(char *) "pt", NULL
33793 };
33794
33795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33797 if (!SWIG_IsOK(res1)) {
33798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33799 }
33800 arg1 = reinterpret_cast< wxWindow * >(argp1);
33801 {
33802 arg2 = &temp2;
33803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33804 }
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33812 return resultobj;
33813 fail:
33814 return NULL;
33815 }
33816
33817
33818 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33819 PyObject *resultobj = 0;
33820 wxWindow *arg1 = (wxWindow *) 0 ;
33821 wxSize *arg2 = 0 ;
33822 wxSize result;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 wxSize temp2 ;
33826 PyObject * obj0 = 0 ;
33827 PyObject * obj1 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "sz", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 arg2 = &temp2;
33840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33841 }
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33856 PyObject *resultobj = 0;
33857 wxWindow *arg1 = (wxWindow *) 0 ;
33858 wxPoint *arg2 = 0 ;
33859 wxPoint result;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 wxPoint temp2 ;
33863 PyObject * obj0 = 0 ;
33864 PyObject * obj1 = 0 ;
33865 char * kwnames[] = {
33866 (char *) "self",(char *) "pt", NULL
33867 };
33868
33869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33871 if (!SWIG_IsOK(res1)) {
33872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33873 }
33874 arg1 = reinterpret_cast< wxWindow * >(argp1);
33875 {
33876 arg2 = &temp2;
33877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33878 }
33879 {
33880 PyThreadState* __tstate = wxPyBeginAllowThreads();
33881 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33893 PyObject *resultobj = 0;
33894 wxWindow *arg1 = (wxWindow *) 0 ;
33895 wxSize *arg2 = 0 ;
33896 wxSize result;
33897 void *argp1 = 0 ;
33898 int res1 = 0 ;
33899 wxSize temp2 ;
33900 PyObject * obj0 = 0 ;
33901 PyObject * obj1 = 0 ;
33902 char * kwnames[] = {
33903 (char *) "self",(char *) "sz", NULL
33904 };
33905
33906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33908 if (!SWIG_IsOK(res1)) {
33909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33910 }
33911 arg1 = reinterpret_cast< wxWindow * >(argp1);
33912 {
33913 arg2 = &temp2;
33914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33915 }
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj = 0;
33931 wxWindow *arg1 = (wxWindow *) 0 ;
33932 wxPoint *arg2 = 0 ;
33933 wxPoint result;
33934 void *argp1 = 0 ;
33935 int res1 = 0 ;
33936 wxPoint temp2 ;
33937 PyObject * obj0 = 0 ;
33938 PyObject * obj1 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "pt", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33947 }
33948 arg1 = reinterpret_cast< wxWindow * >(argp1);
33949 {
33950 arg2 = &temp2;
33951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33952 }
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 wxWindow *arg1 = (wxWindow *) 0 ;
33969 wxSize *arg2 = 0 ;
33970 wxSize result;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 wxSize temp2 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "sz", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 {
33987 arg2 = &temp2;
33988 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33989 }
33990 {
33991 PyThreadState* __tstate = wxPyBeginAllowThreads();
33992 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33993 wxPyEndAllowThreads(__tstate);
33994 if (PyErr_Occurred()) SWIG_fail;
33995 }
33996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33997 return resultobj;
33998 fail:
33999 return NULL;
34000 }
34001
34002
34003 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34004 PyObject *resultobj = 0;
34005 wxWindow *arg1 = (wxWindow *) 0 ;
34006 int arg2 ;
34007 int arg3 ;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 int val2 ;
34011 int ecode2 = 0 ;
34012 int val3 ;
34013 int ecode3 = 0 ;
34014 PyObject * obj0 = 0 ;
34015 PyObject * obj1 = 0 ;
34016 PyObject * obj2 = 0 ;
34017 char * kwnames[] = {
34018 (char *) "self",(char *) "x",(char *) "y", NULL
34019 };
34020
34021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34023 if (!SWIG_IsOK(res1)) {
34024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34025 }
34026 arg1 = reinterpret_cast< wxWindow * >(argp1);
34027 ecode2 = SWIG_AsVal_int(obj1, &val2);
34028 if (!SWIG_IsOK(ecode2)) {
34029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34030 }
34031 arg2 = static_cast< int >(val2);
34032 ecode3 = SWIG_AsVal_int(obj2, &val3);
34033 if (!SWIG_IsOK(ecode3)) {
34034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34035 }
34036 arg3 = static_cast< int >(val3);
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 (arg1)->WarpPointer(arg2,arg3);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = SWIG_Py_Void();
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34051 PyObject *resultobj = 0;
34052 wxWindow *arg1 = (wxWindow *) 0 ;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 PyObject *swig_obj[1] ;
34056
34057 if (!args) SWIG_fail;
34058 swig_obj[0] = args;
34059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34062 }
34063 arg1 = reinterpret_cast< wxWindow * >(argp1);
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 (arg1)->CaptureMouse();
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 resultobj = SWIG_Py_Void();
34071 return resultobj;
34072 fail:
34073 return NULL;
34074 }
34075
34076
34077 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34078 PyObject *resultobj = 0;
34079 wxWindow *arg1 = (wxWindow *) 0 ;
34080 void *argp1 = 0 ;
34081 int res1 = 0 ;
34082 PyObject *swig_obj[1] ;
34083
34084 if (!args) SWIG_fail;
34085 swig_obj[0] = args;
34086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34087 if (!SWIG_IsOK(res1)) {
34088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34089 }
34090 arg1 = reinterpret_cast< wxWindow * >(argp1);
34091 {
34092 PyThreadState* __tstate = wxPyBeginAllowThreads();
34093 (arg1)->ReleaseMouse();
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 resultobj = SWIG_Py_Void();
34098 return resultobj;
34099 fail:
34100 return NULL;
34101 }
34102
34103
34104 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34105 PyObject *resultobj = 0;
34106 wxWindow *result = 0 ;
34107
34108 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34109 {
34110 if (!wxPyCheckForApp()) SWIG_fail;
34111 PyThreadState* __tstate = wxPyBeginAllowThreads();
34112 result = (wxWindow *)wxWindow::GetCapture();
34113 wxPyEndAllowThreads(__tstate);
34114 if (PyErr_Occurred()) SWIG_fail;
34115 }
34116 {
34117 resultobj = wxPyMake_wxObject(result, 0);
34118 }
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 bool result;
34129 void *argp1 = 0 ;
34130 int res1 = 0 ;
34131 PyObject *swig_obj[1] ;
34132
34133 if (!args) SWIG_fail;
34134 swig_obj[0] = args;
34135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34136 if (!SWIG_IsOK(res1)) {
34137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34138 }
34139 arg1 = reinterpret_cast< wxWindow * >(argp1);
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 result = (bool)((wxWindow const *)arg1)->HasCapture();
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 {
34147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34148 }
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = 0;
34157 wxWindow *arg1 = (wxWindow *) 0 ;
34158 bool arg2 = (bool) true ;
34159 wxRect *arg3 = (wxRect *) NULL ;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 bool val2 ;
34163 int ecode2 = 0 ;
34164 void *argp3 = 0 ;
34165 int res3 = 0 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 PyObject * obj2 = 0 ;
34169 char * kwnames[] = {
34170 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34171 };
34172
34173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34177 }
34178 arg1 = reinterpret_cast< wxWindow * >(argp1);
34179 if (obj1) {
34180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34181 if (!SWIG_IsOK(ecode2)) {
34182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34183 }
34184 arg2 = static_cast< bool >(val2);
34185 }
34186 if (obj2) {
34187 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34188 if (!SWIG_IsOK(res3)) {
34189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34190 }
34191 arg3 = reinterpret_cast< wxRect * >(argp3);
34192 }
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34196 wxPyEndAllowThreads(__tstate);
34197 if (PyErr_Occurred()) SWIG_fail;
34198 }
34199 resultobj = SWIG_Py_Void();
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34207 PyObject *resultobj = 0;
34208 wxWindow *arg1 = (wxWindow *) 0 ;
34209 wxRect *arg2 = 0 ;
34210 bool arg3 = (bool) true ;
34211 void *argp1 = 0 ;
34212 int res1 = 0 ;
34213 wxRect temp2 ;
34214 bool val3 ;
34215 int ecode3 = 0 ;
34216 PyObject * obj0 = 0 ;
34217 PyObject * obj1 = 0 ;
34218 PyObject * obj2 = 0 ;
34219 char * kwnames[] = {
34220 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34221 };
34222
34223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34225 if (!SWIG_IsOK(res1)) {
34226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34227 }
34228 arg1 = reinterpret_cast< wxWindow * >(argp1);
34229 {
34230 arg2 = &temp2;
34231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34232 }
34233 if (obj2) {
34234 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34235 if (!SWIG_IsOK(ecode3)) {
34236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34237 }
34238 arg3 = static_cast< bool >(val3);
34239 }
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_Py_Void();
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 PyObject *resultobj = 0;
34255 wxWindow *arg1 = (wxWindow *) 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 PyObject *swig_obj[1] ;
34259
34260 if (!args) SWIG_fail;
34261 swig_obj[0] = args;
34262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34263 if (!SWIG_IsOK(res1)) {
34264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34265 }
34266 arg1 = reinterpret_cast< wxWindow * >(argp1);
34267 {
34268 PyThreadState* __tstate = wxPyBeginAllowThreads();
34269 (arg1)->Update();
34270 wxPyEndAllowThreads(__tstate);
34271 if (PyErr_Occurred()) SWIG_fail;
34272 }
34273 resultobj = SWIG_Py_Void();
34274 return resultobj;
34275 fail:
34276 return NULL;
34277 }
34278
34279
34280 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34281 PyObject *resultobj = 0;
34282 wxWindow *arg1 = (wxWindow *) 0 ;
34283 void *argp1 = 0 ;
34284 int res1 = 0 ;
34285 PyObject *swig_obj[1] ;
34286
34287 if (!args) SWIG_fail;
34288 swig_obj[0] = args;
34289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34290 if (!SWIG_IsOK(res1)) {
34291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34292 }
34293 arg1 = reinterpret_cast< wxWindow * >(argp1);
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 (arg1)->ClearBackground();
34297 wxPyEndAllowThreads(__tstate);
34298 if (PyErr_Occurred()) SWIG_fail;
34299 }
34300 resultobj = SWIG_Py_Void();
34301 return resultobj;
34302 fail:
34303 return NULL;
34304 }
34305
34306
34307 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34308 PyObject *resultobj = 0;
34309 wxWindow *arg1 = (wxWindow *) 0 ;
34310 void *argp1 = 0 ;
34311 int res1 = 0 ;
34312 PyObject *swig_obj[1] ;
34313
34314 if (!args) SWIG_fail;
34315 swig_obj[0] = args;
34316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34317 if (!SWIG_IsOK(res1)) {
34318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34319 }
34320 arg1 = reinterpret_cast< wxWindow * >(argp1);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->Freeze();
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 resultobj = SWIG_Py_Void();
34328 return resultobj;
34329 fail:
34330 return NULL;
34331 }
34332
34333
34334 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34335 PyObject *resultobj = 0;
34336 wxWindow *arg1 = (wxWindow *) 0 ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 PyObject *swig_obj[1] ;
34340
34341 if (!args) SWIG_fail;
34342 swig_obj[0] = args;
34343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 (arg1)->Thaw();
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 resultobj = SWIG_Py_Void();
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34362 PyObject *resultobj = 0;
34363 wxWindow *arg1 = (wxWindow *) 0 ;
34364 wxDC *arg2 = 0 ;
34365 void *argp1 = 0 ;
34366 int res1 = 0 ;
34367 void *argp2 = 0 ;
34368 int res2 = 0 ;
34369 PyObject * obj0 = 0 ;
34370 PyObject * obj1 = 0 ;
34371 char * kwnames[] = {
34372 (char *) "self",(char *) "dc", NULL
34373 };
34374
34375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34377 if (!SWIG_IsOK(res1)) {
34378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34379 }
34380 arg1 = reinterpret_cast< wxWindow * >(argp1);
34381 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34382 if (!SWIG_IsOK(res2)) {
34383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34384 }
34385 if (!argp2) {
34386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34387 }
34388 arg2 = reinterpret_cast< wxDC * >(argp2);
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->PrepareDC(*arg2);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 wxRegion *result = 0 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject *swig_obj[1] ;
34409
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34415 }
34416 arg1 = reinterpret_cast< wxWindow * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 {
34420 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34421 result = (wxRegion *) &_result_ref;
34422 }
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34434 PyObject *resultobj = 0;
34435 wxWindow *arg1 = (wxWindow *) 0 ;
34436 wxRect result;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 PyObject *swig_obj[1] ;
34440
34441 if (!args) SWIG_fail;
34442 swig_obj[0] = args;
34443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34446 }
34447 arg1 = reinterpret_cast< wxWindow * >(argp1);
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34462 PyObject *resultobj = 0;
34463 wxWindow *arg1 = (wxWindow *) 0 ;
34464 int arg2 ;
34465 int arg3 ;
34466 int arg4 = (int) 1 ;
34467 int arg5 = (int) 1 ;
34468 bool result;
34469 void *argp1 = 0 ;
34470 int res1 = 0 ;
34471 int val2 ;
34472 int ecode2 = 0 ;
34473 int val3 ;
34474 int ecode3 = 0 ;
34475 int val4 ;
34476 int ecode4 = 0 ;
34477 int val5 ;
34478 int ecode5 = 0 ;
34479 PyObject * obj0 = 0 ;
34480 PyObject * obj1 = 0 ;
34481 PyObject * obj2 = 0 ;
34482 PyObject * obj3 = 0 ;
34483 PyObject * obj4 = 0 ;
34484 char * kwnames[] = {
34485 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34486 };
34487
34488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 ecode2 = SWIG_AsVal_int(obj1, &val2);
34495 if (!SWIG_IsOK(ecode2)) {
34496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34497 }
34498 arg2 = static_cast< int >(val2);
34499 ecode3 = SWIG_AsVal_int(obj2, &val3);
34500 if (!SWIG_IsOK(ecode3)) {
34501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34502 }
34503 arg3 = static_cast< int >(val3);
34504 if (obj3) {
34505 ecode4 = SWIG_AsVal_int(obj3, &val4);
34506 if (!SWIG_IsOK(ecode4)) {
34507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34508 }
34509 arg4 = static_cast< int >(val4);
34510 }
34511 if (obj4) {
34512 ecode5 = SWIG_AsVal_int(obj4, &val5);
34513 if (!SWIG_IsOK(ecode5)) {
34514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34515 }
34516 arg5 = static_cast< int >(val5);
34517 }
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 {
34525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34526 }
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 wxPoint *arg2 = 0 ;
34537 bool result;
34538 void *argp1 = 0 ;
34539 int res1 = 0 ;
34540 wxPoint temp2 ;
34541 PyObject * obj0 = 0 ;
34542 PyObject * obj1 = 0 ;
34543 char * kwnames[] = {
34544 (char *) "self",(char *) "pt", NULL
34545 };
34546
34547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34549 if (!SWIG_IsOK(res1)) {
34550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34551 }
34552 arg1 = reinterpret_cast< wxWindow * >(argp1);
34553 {
34554 arg2 = &temp2;
34555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34556 }
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 {
34564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34565 }
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 wxRect *arg2 = 0 ;
34576 bool result;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 wxRect temp2 ;
34580 PyObject * obj0 = 0 ;
34581 PyObject * obj1 = 0 ;
34582 char * kwnames[] = {
34583 (char *) "self",(char *) "rect", NULL
34584 };
34585
34586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34588 if (!SWIG_IsOK(res1)) {
34589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34590 }
34591 arg1 = reinterpret_cast< wxWindow * >(argp1);
34592 {
34593 arg2 = &temp2;
34594 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 {
34603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34604 }
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 SwigValueWrapper<wxVisualAttributes > result;
34615 void *argp1 = 0 ;
34616 int res1 = 0 ;
34617 PyObject *swig_obj[1] ;
34618
34619 if (!args) SWIG_fail;
34620 swig_obj[0] = args;
34621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34624 }
34625 arg1 = reinterpret_cast< wxWindow * >(argp1);
34626 {
34627 PyThreadState* __tstate = wxPyBeginAllowThreads();
34628 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj = 0;
34641 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34642 SwigValueWrapper<wxVisualAttributes > result;
34643 int val1 ;
34644 int ecode1 = 0 ;
34645 PyObject * obj0 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "variant", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34651 if (obj0) {
34652 ecode1 = SWIG_AsVal_int(obj0, &val1);
34653 if (!SWIG_IsOK(ecode1)) {
34654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34655 }
34656 arg1 = static_cast< wxWindowVariant >(val1);
34657 }
34658 {
34659 if (!wxPyCheckForApp()) SWIG_fail;
34660 PyThreadState* __tstate = wxPyBeginAllowThreads();
34661 result = wxWindow::GetClassDefaultAttributes(arg1);
34662 wxPyEndAllowThreads(__tstate);
34663 if (PyErr_Occurred()) SWIG_fail;
34664 }
34665 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34666 return resultobj;
34667 fail:
34668 return NULL;
34669 }
34670
34671
34672 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34673 PyObject *resultobj = 0;
34674 wxWindow *arg1 = (wxWindow *) 0 ;
34675 wxColour *arg2 = 0 ;
34676 bool result;
34677 void *argp1 = 0 ;
34678 int res1 = 0 ;
34679 wxColour temp2 ;
34680 PyObject * obj0 = 0 ;
34681 PyObject * obj1 = 0 ;
34682 char * kwnames[] = {
34683 (char *) "self",(char *) "colour", NULL
34684 };
34685
34686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34688 if (!SWIG_IsOK(res1)) {
34689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34690 }
34691 arg1 = reinterpret_cast< wxWindow * >(argp1);
34692 {
34693 arg2 = &temp2;
34694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 wxColour *arg2 = 0 ;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 wxColour temp2 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "colour", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 {
34731 arg2 = &temp2;
34732 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 resultobj = SWIG_Py_Void();
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 wxColour *arg2 = 0 ;
34751 bool result;
34752 void *argp1 = 0 ;
34753 int res1 = 0 ;
34754 wxColour temp2 ;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 char * kwnames[] = {
34758 (char *) "self",(char *) "colour", NULL
34759 };
34760
34761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34765 }
34766 arg1 = reinterpret_cast< wxWindow * >(argp1);
34767 {
34768 arg2 = &temp2;
34769 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34770 }
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 {
34778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34779 }
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34787 PyObject *resultobj = 0;
34788 wxWindow *arg1 = (wxWindow *) 0 ;
34789 wxColour *arg2 = 0 ;
34790 void *argp1 = 0 ;
34791 int res1 = 0 ;
34792 wxColour temp2 ;
34793 PyObject * obj0 = 0 ;
34794 PyObject * obj1 = 0 ;
34795 char * kwnames[] = {
34796 (char *) "self",(char *) "colour", NULL
34797 };
34798
34799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34803 }
34804 arg1 = reinterpret_cast< wxWindow * >(argp1);
34805 {
34806 arg2 = &temp2;
34807 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34808 }
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 resultobj = SWIG_Py_Void();
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34823 PyObject *resultobj = 0;
34824 wxWindow *arg1 = (wxWindow *) 0 ;
34825 wxColour result;
34826 void *argp1 = 0 ;
34827 int res1 = 0 ;
34828 PyObject *swig_obj[1] ;
34829
34830 if (!args) SWIG_fail;
34831 swig_obj[0] = args;
34832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34833 if (!SWIG_IsOK(res1)) {
34834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34835 }
34836 arg1 = reinterpret_cast< wxWindow * >(argp1);
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxColour result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 PyObject *swig_obj[1] ;
34857
34858 if (!args) SWIG_fail;
34859 swig_obj[0] = args;
34860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = ((wxWindow const *)arg1)->GetForegroundColour();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 bool result;
34882 void *argp1 = 0 ;
34883 int res1 = 0 ;
34884 PyObject *swig_obj[1] ;
34885
34886 if (!args) SWIG_fail;
34887 swig_obj[0] = args;
34888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34889 if (!SWIG_IsOK(res1)) {
34890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34891 }
34892 arg1 = reinterpret_cast< wxWindow * >(argp1);
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34909 PyObject *resultobj = 0;
34910 wxWindow *arg1 = (wxWindow *) 0 ;
34911 bool result;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 PyObject *swig_obj[1] ;
34915
34916 if (!args) SWIG_fail;
34917 swig_obj[0] = args;
34918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34921 }
34922 arg1 = reinterpret_cast< wxWindow * >(argp1);
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34926 wxPyEndAllowThreads(__tstate);
34927 if (PyErr_Occurred()) SWIG_fail;
34928 }
34929 {
34930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34931 }
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 wxBackgroundStyle arg2 ;
34942 bool result;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 int val2 ;
34946 int ecode2 = 0 ;
34947 PyObject * obj0 = 0 ;
34948 PyObject * obj1 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "self",(char *) "style", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 ecode2 = SWIG_AsVal_int(obj1, &val2);
34960 if (!SWIG_IsOK(ecode2)) {
34961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34962 }
34963 arg2 = static_cast< wxBackgroundStyle >(val2);
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 {
34971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34972 }
34973 return resultobj;
34974 fail:
34975 return NULL;
34976 }
34977
34978
34979 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34980 PyObject *resultobj = 0;
34981 wxWindow *arg1 = (wxWindow *) 0 ;
34982 wxBackgroundStyle result;
34983 void *argp1 = 0 ;
34984 int res1 = 0 ;
34985 PyObject *swig_obj[1] ;
34986
34987 if (!args) SWIG_fail;
34988 swig_obj[0] = args;
34989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34990 if (!SWIG_IsOK(res1)) {
34991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34992 }
34993 arg1 = reinterpret_cast< wxWindow * >(argp1);
34994 {
34995 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34997 wxPyEndAllowThreads(__tstate);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 }
35000 resultobj = SWIG_From_int(static_cast< int >(result));
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35008 PyObject *resultobj = 0;
35009 wxWindow *arg1 = (wxWindow *) 0 ;
35010 bool result;
35011 void *argp1 = 0 ;
35012 int res1 = 0 ;
35013 PyObject *swig_obj[1] ;
35014
35015 if (!args) SWIG_fail;
35016 swig_obj[0] = args;
35017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35018 if (!SWIG_IsOK(res1)) {
35019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35020 }
35021 arg1 = reinterpret_cast< wxWindow * >(argp1);
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = (bool)(arg1)->HasTransparentBackground();
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 {
35029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35030 }
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35038 PyObject *resultobj = 0;
35039 wxWindow *arg1 = (wxWindow *) 0 ;
35040 wxCursor *arg2 = 0 ;
35041 bool result;
35042 void *argp1 = 0 ;
35043 int res1 = 0 ;
35044 void *argp2 = 0 ;
35045 int res2 = 0 ;
35046 PyObject * obj0 = 0 ;
35047 PyObject * obj1 = 0 ;
35048 char * kwnames[] = {
35049 (char *) "self",(char *) "cursor", NULL
35050 };
35051
35052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35056 }
35057 arg1 = reinterpret_cast< wxWindow * >(argp1);
35058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35059 if (!SWIG_IsOK(res2)) {
35060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35061 }
35062 if (!argp2) {
35063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35064 }
35065 arg2 = reinterpret_cast< wxCursor * >(argp2);
35066 {
35067 PyThreadState* __tstate = wxPyBeginAllowThreads();
35068 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35069 wxPyEndAllowThreads(__tstate);
35070 if (PyErr_Occurred()) SWIG_fail;
35071 }
35072 {
35073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35074 }
35075 return resultobj;
35076 fail:
35077 return NULL;
35078 }
35079
35080
35081 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35082 PyObject *resultobj = 0;
35083 wxWindow *arg1 = (wxWindow *) 0 ;
35084 wxCursor result;
35085 void *argp1 = 0 ;
35086 int res1 = 0 ;
35087 PyObject *swig_obj[1] ;
35088
35089 if (!args) SWIG_fail;
35090 swig_obj[0] = args;
35091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35092 if (!SWIG_IsOK(res1)) {
35093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35094 }
35095 arg1 = reinterpret_cast< wxWindow * >(argp1);
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (arg1)->GetCursor();
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxWindow *arg1 = (wxWindow *) 0 ;
35112 wxFont *arg2 = 0 ;
35113 bool result;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 void *argp2 = 0 ;
35117 int res2 = 0 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 char * kwnames[] = {
35121 (char *) "self",(char *) "font", NULL
35122 };
35123
35124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35131 if (!SWIG_IsOK(res2)) {
35132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35133 }
35134 if (!argp2) {
35135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35136 }
35137 arg2 = reinterpret_cast< wxFont * >(argp2);
35138 {
35139 PyThreadState* __tstate = wxPyBeginAllowThreads();
35140 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 {
35145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35146 }
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj = 0;
35155 wxWindow *arg1 = (wxWindow *) 0 ;
35156 wxFont *arg2 = 0 ;
35157 void *argp1 = 0 ;
35158 int res1 = 0 ;
35159 void *argp2 = 0 ;
35160 int res2 = 0 ;
35161 PyObject * obj0 = 0 ;
35162 PyObject * obj1 = 0 ;
35163 char * kwnames[] = {
35164 (char *) "self",(char *) "font", NULL
35165 };
35166
35167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35174 if (!SWIG_IsOK(res2)) {
35175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35176 }
35177 if (!argp2) {
35178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35179 }
35180 arg2 = reinterpret_cast< wxFont * >(argp2);
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 (arg1)->SetOwnFont((wxFont const &)*arg2);
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 resultobj = SWIG_Py_Void();
35188 return resultobj;
35189 fail:
35190 return NULL;
35191 }
35192
35193
35194 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35195 PyObject *resultobj = 0;
35196 wxWindow *arg1 = (wxWindow *) 0 ;
35197 wxFont 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_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35207 }
35208 arg1 = reinterpret_cast< wxWindow * >(argp1);
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 result = (arg1)->GetFont();
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35223 PyObject *resultobj = 0;
35224 wxWindow *arg1 = (wxWindow *) 0 ;
35225 wxCaret *arg2 = (wxCaret *) 0 ;
35226 void *argp1 = 0 ;
35227 int res1 = 0 ;
35228 int res2 = 0 ;
35229 PyObject * obj0 = 0 ;
35230 PyObject * obj1 = 0 ;
35231 char * kwnames[] = {
35232 (char *) "self",(char *) "caret", NULL
35233 };
35234
35235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35239 }
35240 arg1 = reinterpret_cast< wxWindow * >(argp1);
35241 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35242 if (!SWIG_IsOK(res2)) {
35243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35244 }
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 (arg1)->SetCaret(arg2);
35248 wxPyEndAllowThreads(__tstate);
35249 if (PyErr_Occurred()) SWIG_fail;
35250 }
35251 resultobj = SWIG_Py_Void();
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 wxCaret *result = 0 ;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35271 }
35272 arg1 = reinterpret_cast< wxWindow * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 int result;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 PyObject *swig_obj[1] ;
35293
35294 if (!args) SWIG_fail;
35295 swig_obj[0] = args;
35296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35299 }
35300 arg1 = reinterpret_cast< wxWindow * >(argp1);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_From_int(static_cast< int >(result));
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 int result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_From_int(static_cast< int >(result));
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 wxString *arg2 = 0 ;
35346 int *arg3 = (int *) 0 ;
35347 int *arg4 = (int *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 bool temp2 = false ;
35351 int temp3 ;
35352 int res3 = SWIG_TMPOBJ ;
35353 int temp4 ;
35354 int res4 = SWIG_TMPOBJ ;
35355 PyObject * obj0 = 0 ;
35356 PyObject * obj1 = 0 ;
35357 char * kwnames[] = {
35358 (char *) "self",(char *) "string", NULL
35359 };
35360
35361 arg3 = &temp3;
35362 arg4 = &temp4;
35363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35365 if (!SWIG_IsOK(res1)) {
35366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35367 }
35368 arg1 = reinterpret_cast< wxWindow * >(argp1);
35369 {
35370 arg2 = wxString_in_helper(obj1);
35371 if (arg2 == NULL) SWIG_fail;
35372 temp2 = true;
35373 }
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 resultobj = SWIG_Py_Void();
35381 if (SWIG_IsTmpObj(res3)) {
35382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35383 } else {
35384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35386 }
35387 if (SWIG_IsTmpObj(res4)) {
35388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35389 } else {
35390 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35392 }
35393 {
35394 if (temp2)
35395 delete arg2;
35396 }
35397 return resultobj;
35398 fail:
35399 {
35400 if (temp2)
35401 delete arg2;
35402 }
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35408 PyObject *resultobj = 0;
35409 wxWindow *arg1 = (wxWindow *) 0 ;
35410 wxString *arg2 = 0 ;
35411 int *arg3 = (int *) 0 ;
35412 int *arg4 = (int *) 0 ;
35413 int *arg5 = (int *) 0 ;
35414 int *arg6 = (int *) 0 ;
35415 wxFont *arg7 = (wxFont *) NULL ;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 bool temp2 = false ;
35419 int temp3 ;
35420 int res3 = SWIG_TMPOBJ ;
35421 int temp4 ;
35422 int res4 = SWIG_TMPOBJ ;
35423 int temp5 ;
35424 int res5 = SWIG_TMPOBJ ;
35425 int temp6 ;
35426 int res6 = SWIG_TMPOBJ ;
35427 void *argp7 = 0 ;
35428 int res7 = 0 ;
35429 PyObject * obj0 = 0 ;
35430 PyObject * obj1 = 0 ;
35431 PyObject * obj2 = 0 ;
35432 char * kwnames[] = {
35433 (char *) "self",(char *) "string",(char *) "font", NULL
35434 };
35435
35436 arg3 = &temp3;
35437 arg4 = &temp4;
35438 arg5 = &temp5;
35439 arg6 = &temp6;
35440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35442 if (!SWIG_IsOK(res1)) {
35443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35444 }
35445 arg1 = reinterpret_cast< wxWindow * >(argp1);
35446 {
35447 arg2 = wxString_in_helper(obj1);
35448 if (arg2 == NULL) SWIG_fail;
35449 temp2 = true;
35450 }
35451 if (obj2) {
35452 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35453 if (!SWIG_IsOK(res7)) {
35454 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35455 }
35456 arg7 = reinterpret_cast< wxFont * >(argp7);
35457 }
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 resultobj = SWIG_Py_Void();
35465 if (SWIG_IsTmpObj(res3)) {
35466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35467 } else {
35468 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35470 }
35471 if (SWIG_IsTmpObj(res4)) {
35472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35473 } else {
35474 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35476 }
35477 if (SWIG_IsTmpObj(res5)) {
35478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35479 } else {
35480 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35482 }
35483 if (SWIG_IsTmpObj(res6)) {
35484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35485 } else {
35486 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35488 }
35489 {
35490 if (temp2)
35491 delete arg2;
35492 }
35493 return resultobj;
35494 fail:
35495 {
35496 if (temp2)
35497 delete arg2;
35498 }
35499 return NULL;
35500 }
35501
35502
35503 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj = 0;
35505 wxWindow *arg1 = (wxWindow *) 0 ;
35506 int *arg2 = (int *) 0 ;
35507 int *arg3 = (int *) 0 ;
35508 void *argp1 = 0 ;
35509 int res1 = 0 ;
35510 int temp2 ;
35511 int res2 = 0 ;
35512 int temp3 ;
35513 int res3 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 PyObject * obj2 = 0 ;
35517 char * kwnames[] = {
35518 (char *) "self",(char *) "x",(char *) "y", NULL
35519 };
35520
35521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35523 if (!SWIG_IsOK(res1)) {
35524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35525 }
35526 arg1 = reinterpret_cast< wxWindow * >(argp1);
35527 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35528 int val;
35529 int ecode = SWIG_AsVal_int(obj1, &val);
35530 if (!SWIG_IsOK(ecode)) {
35531 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35532 }
35533 temp2 = static_cast< int >(val);
35534 arg2 = &temp2;
35535 res2 = SWIG_AddTmpMask(ecode);
35536 }
35537 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35538 int val;
35539 int ecode = SWIG_AsVal_int(obj2, &val);
35540 if (!SWIG_IsOK(ecode)) {
35541 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35542 }
35543 temp3 = static_cast< int >(val);
35544 arg3 = &temp3;
35545 res3 = SWIG_AddTmpMask(ecode);
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 resultobj = SWIG_Py_Void();
35554 if (SWIG_IsTmpObj(res2)) {
35555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35556 } else {
35557 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35559 }
35560 if (SWIG_IsTmpObj(res3)) {
35561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35562 } else {
35563 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = 0;
35574 wxWindow *arg1 = (wxWindow *) 0 ;
35575 int *arg2 = (int *) 0 ;
35576 int *arg3 = (int *) 0 ;
35577 void *argp1 = 0 ;
35578 int res1 = 0 ;
35579 int temp2 ;
35580 int res2 = 0 ;
35581 int temp3 ;
35582 int res3 = 0 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 PyObject * obj2 = 0 ;
35586 char * kwnames[] = {
35587 (char *) "self",(char *) "x",(char *) "y", NULL
35588 };
35589
35590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35594 }
35595 arg1 = reinterpret_cast< wxWindow * >(argp1);
35596 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35597 int val;
35598 int ecode = SWIG_AsVal_int(obj1, &val);
35599 if (!SWIG_IsOK(ecode)) {
35600 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35601 }
35602 temp2 = static_cast< int >(val);
35603 arg2 = &temp2;
35604 res2 = SWIG_AddTmpMask(ecode);
35605 }
35606 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35607 int val;
35608 int ecode = SWIG_AsVal_int(obj2, &val);
35609 if (!SWIG_IsOK(ecode)) {
35610 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35611 }
35612 temp3 = static_cast< int >(val);
35613 arg3 = &temp3;
35614 res3 = SWIG_AddTmpMask(ecode);
35615 }
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35619 wxPyEndAllowThreads(__tstate);
35620 if (PyErr_Occurred()) SWIG_fail;
35621 }
35622 resultobj = SWIG_Py_Void();
35623 if (SWIG_IsTmpObj(res2)) {
35624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35625 } else {
35626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35628 }
35629 if (SWIG_IsTmpObj(res3)) {
35630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35631 } else {
35632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 wxPoint *arg2 = 0 ;
35645 wxPoint result;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 wxPoint temp2 ;
35649 PyObject * obj0 = 0 ;
35650 PyObject * obj1 = 0 ;
35651 char * kwnames[] = {
35652 (char *) "self",(char *) "pt", NULL
35653 };
35654
35655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 arg2 = &temp2;
35663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35664 }
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35679 PyObject *resultobj = 0;
35680 wxWindow *arg1 = (wxWindow *) 0 ;
35681 wxPoint *arg2 = 0 ;
35682 wxPoint result;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 wxPoint temp2 ;
35686 PyObject * obj0 = 0 ;
35687 PyObject * obj1 = 0 ;
35688 char * kwnames[] = {
35689 (char *) "self",(char *) "pt", NULL
35690 };
35691
35692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35694 if (!SWIG_IsOK(res1)) {
35695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35696 }
35697 arg1 = reinterpret_cast< wxWindow * >(argp1);
35698 {
35699 arg2 = &temp2;
35700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35701 }
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35716 PyObject *resultobj = 0;
35717 wxWindow *arg1 = (wxWindow *) 0 ;
35718 int arg2 ;
35719 int arg3 ;
35720 wxHitTest result;
35721 void *argp1 = 0 ;
35722 int res1 = 0 ;
35723 int val2 ;
35724 int ecode2 = 0 ;
35725 int val3 ;
35726 int ecode3 = 0 ;
35727 PyObject * obj0 = 0 ;
35728 PyObject * obj1 = 0 ;
35729 PyObject * obj2 = 0 ;
35730 char * kwnames[] = {
35731 (char *) "self",(char *) "x",(char *) "y", NULL
35732 };
35733
35734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35736 if (!SWIG_IsOK(res1)) {
35737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35738 }
35739 arg1 = reinterpret_cast< wxWindow * >(argp1);
35740 ecode2 = SWIG_AsVal_int(obj1, &val2);
35741 if (!SWIG_IsOK(ecode2)) {
35742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35743 }
35744 arg2 = static_cast< int >(val2);
35745 ecode3 = SWIG_AsVal_int(obj2, &val3);
35746 if (!SWIG_IsOK(ecode3)) {
35747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35748 }
35749 arg3 = static_cast< int >(val3);
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 resultobj = SWIG_From_int(static_cast< int >(result));
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35764 PyObject *resultobj = 0;
35765 wxWindow *arg1 = (wxWindow *) 0 ;
35766 wxPoint *arg2 = 0 ;
35767 wxHitTest result;
35768 void *argp1 = 0 ;
35769 int res1 = 0 ;
35770 wxPoint temp2 ;
35771 PyObject * obj0 = 0 ;
35772 PyObject * obj1 = 0 ;
35773 char * kwnames[] = {
35774 (char *) "self",(char *) "pt", NULL
35775 };
35776
35777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 arg2 = &temp2;
35785 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35786 }
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 resultobj = SWIG_From_int(static_cast< int >(result));
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 long arg2 ;
35804 wxBorder result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 long val2 ;
35808 int ecode2 = 0 ;
35809
35810 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35817 if (!SWIG_IsOK(ecode2)) {
35818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35819 }
35820 arg2 = static_cast< long >(val2);
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 resultobj = SWIG_From_int(static_cast< int >(result));
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35835 PyObject *resultobj = 0;
35836 wxWindow *arg1 = (wxWindow *) 0 ;
35837 wxBorder result;
35838 void *argp1 = 0 ;
35839 int res1 = 0 ;
35840
35841 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35843 if (!SWIG_IsOK(res1)) {
35844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35845 }
35846 arg1 = reinterpret_cast< wxWindow * >(argp1);
35847 {
35848 PyThreadState* __tstate = wxPyBeginAllowThreads();
35849 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35850 wxPyEndAllowThreads(__tstate);
35851 if (PyErr_Occurred()) SWIG_fail;
35852 }
35853 resultobj = SWIG_From_int(static_cast< int >(result));
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35861 int argc;
35862 PyObject *argv[3];
35863
35864 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35865 --argc;
35866 if (argc == 1) {
35867 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35868 }
35869 if (argc == 2) {
35870 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35871 }
35872
35873 fail:
35874 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35875 return NULL;
35876 }
35877
35878
35879 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj = 0;
35881 wxWindow *arg1 = (wxWindow *) 0 ;
35882 long arg2 = (long) wxUPDATE_UI_NONE ;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 long val2 ;
35886 int ecode2 = 0 ;
35887 PyObject * obj0 = 0 ;
35888 PyObject * obj1 = 0 ;
35889 char * kwnames[] = {
35890 (char *) "self",(char *) "flags", NULL
35891 };
35892
35893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35895 if (!SWIG_IsOK(res1)) {
35896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35897 }
35898 arg1 = reinterpret_cast< wxWindow * >(argp1);
35899 if (obj1) {
35900 ecode2 = SWIG_AsVal_long(obj1, &val2);
35901 if (!SWIG_IsOK(ecode2)) {
35902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35903 }
35904 arg2 = static_cast< long >(val2);
35905 }
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 (arg1)->UpdateWindowUI(arg2);
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 resultobj = SWIG_Py_Void();
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 wxMenu *arg2 = (wxMenu *) 0 ;
35923 int arg3 = (int) -1 ;
35924 int arg4 = (int) -1 ;
35925 bool result;
35926 void *argp1 = 0 ;
35927 int res1 = 0 ;
35928 void *argp2 = 0 ;
35929 int res2 = 0 ;
35930 int val3 ;
35931 int ecode3 = 0 ;
35932 int val4 ;
35933 int ecode4 = 0 ;
35934 PyObject * obj0 = 0 ;
35935 PyObject * obj1 = 0 ;
35936 PyObject * obj2 = 0 ;
35937 PyObject * obj3 = 0 ;
35938 char * kwnames[] = {
35939 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35940 };
35941
35942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35944 if (!SWIG_IsOK(res1)) {
35945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35946 }
35947 arg1 = reinterpret_cast< wxWindow * >(argp1);
35948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35949 if (!SWIG_IsOK(res2)) {
35950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35951 }
35952 arg2 = reinterpret_cast< wxMenu * >(argp2);
35953 if (obj2) {
35954 ecode3 = SWIG_AsVal_int(obj2, &val3);
35955 if (!SWIG_IsOK(ecode3)) {
35956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35957 }
35958 arg3 = static_cast< int >(val3);
35959 }
35960 if (obj3) {
35961 ecode4 = SWIG_AsVal_int(obj3, &val4);
35962 if (!SWIG_IsOK(ecode4)) {
35963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35964 }
35965 arg4 = static_cast< int >(val4);
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35983 PyObject *resultobj = 0;
35984 wxWindow *arg1 = (wxWindow *) 0 ;
35985 wxMenu *arg2 = (wxMenu *) 0 ;
35986 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35987 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35988 bool result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 void *argp2 = 0 ;
35992 int res2 = 0 ;
35993 wxPoint temp3 ;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 PyObject * obj2 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "self",(char *) "menu",(char *) "pos", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36008 if (!SWIG_IsOK(res2)) {
36009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36010 }
36011 arg2 = reinterpret_cast< wxMenu * >(argp2);
36012 if (obj2) {
36013 {
36014 arg3 = &temp3;
36015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36016 }
36017 }
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 {
36025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36026 }
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 long result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36046 }
36047 arg1 = reinterpret_cast< wxWindow * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = (long)wxWindow_GetHandle(arg1);
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 resultobj = SWIG_From_long(static_cast< long >(result));
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj = 0;
36063 wxWindow *arg1 = (wxWindow *) 0 ;
36064 long arg2 ;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 long val2 ;
36068 int ecode2 = 0 ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 char * kwnames[] = {
36072 (char *) "self",(char *) "handle", NULL
36073 };
36074
36075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36079 }
36080 arg1 = reinterpret_cast< wxWindow * >(argp1);
36081 ecode2 = SWIG_AsVal_long(obj1, &val2);
36082 if (!SWIG_IsOK(ecode2)) {
36083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36084 }
36085 arg2 = static_cast< long >(val2);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 wxWindow_AssociateHandle(arg1,arg2);
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 resultobj = SWIG_Py_Void();
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 PyObject *swig_obj[1] ;
36105
36106 if (!args) SWIG_fail;
36107 swig_obj[0] = args;
36108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36109 if (!SWIG_IsOK(res1)) {
36110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36111 }
36112 arg1 = reinterpret_cast< wxWindow * >(argp1);
36113 {
36114 PyThreadState* __tstate = wxPyBeginAllowThreads();
36115 (arg1)->DissociateHandle();
36116 wxPyEndAllowThreads(__tstate);
36117 if (PyErr_Occurred()) SWIG_fail;
36118 }
36119 resultobj = SWIG_Py_Void();
36120 return resultobj;
36121 fail:
36122 return NULL;
36123 }
36124
36125
36126 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36127 PyObject *resultobj = 0;
36128 wxWindow *arg1 = (wxWindow *) 0 ;
36129 int arg2 ;
36130 bool result;
36131 void *argp1 = 0 ;
36132 int res1 = 0 ;
36133 int val2 ;
36134 int ecode2 = 0 ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char * kwnames[] = {
36138 (char *) "self",(char *) "orient", NULL
36139 };
36140
36141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36143 if (!SWIG_IsOK(res1)) {
36144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36145 }
36146 arg1 = reinterpret_cast< wxWindow * >(argp1);
36147 ecode2 = SWIG_AsVal_int(obj1, &val2);
36148 if (!SWIG_IsOK(ecode2)) {
36149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36150 }
36151 arg2 = static_cast< int >(val2);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36168 PyObject *resultobj = 0;
36169 wxWindow *arg1 = (wxWindow *) 0 ;
36170 int arg2 ;
36171 int arg3 ;
36172 int arg4 ;
36173 int arg5 ;
36174 bool arg6 = (bool) true ;
36175 void *argp1 = 0 ;
36176 int res1 = 0 ;
36177 int val2 ;
36178 int ecode2 = 0 ;
36179 int val3 ;
36180 int ecode3 = 0 ;
36181 int val4 ;
36182 int ecode4 = 0 ;
36183 int val5 ;
36184 int ecode5 = 0 ;
36185 bool val6 ;
36186 int ecode6 = 0 ;
36187 PyObject * obj0 = 0 ;
36188 PyObject * obj1 = 0 ;
36189 PyObject * obj2 = 0 ;
36190 PyObject * obj3 = 0 ;
36191 PyObject * obj4 = 0 ;
36192 PyObject * obj5 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 ecode3 = SWIG_AsVal_int(obj2, &val3);
36209 if (!SWIG_IsOK(ecode3)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36211 }
36212 arg3 = static_cast< int >(val3);
36213 ecode4 = SWIG_AsVal_int(obj3, &val4);
36214 if (!SWIG_IsOK(ecode4)) {
36215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36216 }
36217 arg4 = static_cast< int >(val4);
36218 ecode5 = SWIG_AsVal_int(obj4, &val5);
36219 if (!SWIG_IsOK(ecode5)) {
36220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36221 }
36222 arg5 = static_cast< int >(val5);
36223 if (obj5) {
36224 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36225 if (!SWIG_IsOK(ecode6)) {
36226 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36227 }
36228 arg6 = static_cast< bool >(val6);
36229 }
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36233 wxPyEndAllowThreads(__tstate);
36234 if (PyErr_Occurred()) SWIG_fail;
36235 }
36236 resultobj = SWIG_Py_Void();
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36244 PyObject *resultobj = 0;
36245 wxWindow *arg1 = (wxWindow *) 0 ;
36246 int arg2 ;
36247 int arg3 ;
36248 bool arg4 = (bool) true ;
36249 void *argp1 = 0 ;
36250 int res1 = 0 ;
36251 int val2 ;
36252 int ecode2 = 0 ;
36253 int val3 ;
36254 int ecode3 = 0 ;
36255 bool val4 ;
36256 int ecode4 = 0 ;
36257 PyObject * obj0 = 0 ;
36258 PyObject * obj1 = 0 ;
36259 PyObject * obj2 = 0 ;
36260 PyObject * obj3 = 0 ;
36261 char * kwnames[] = {
36262 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36263 };
36264
36265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36267 if (!SWIG_IsOK(res1)) {
36268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36269 }
36270 arg1 = reinterpret_cast< wxWindow * >(argp1);
36271 ecode2 = SWIG_AsVal_int(obj1, &val2);
36272 if (!SWIG_IsOK(ecode2)) {
36273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36274 }
36275 arg2 = static_cast< int >(val2);
36276 ecode3 = SWIG_AsVal_int(obj2, &val3);
36277 if (!SWIG_IsOK(ecode3)) {
36278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36279 }
36280 arg3 = static_cast< int >(val3);
36281 if (obj3) {
36282 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36283 if (!SWIG_IsOK(ecode4)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36285 }
36286 arg4 = static_cast< bool >(val4);
36287 }
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 (arg1)->SetScrollPos(arg2,arg3,arg4);
36291 wxPyEndAllowThreads(__tstate);
36292 if (PyErr_Occurred()) SWIG_fail;
36293 }
36294 resultobj = SWIG_Py_Void();
36295 return resultobj;
36296 fail:
36297 return NULL;
36298 }
36299
36300
36301 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36302 PyObject *resultobj = 0;
36303 wxWindow *arg1 = (wxWindow *) 0 ;
36304 int arg2 ;
36305 int result;
36306 void *argp1 = 0 ;
36307 int res1 = 0 ;
36308 int val2 ;
36309 int ecode2 = 0 ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 char * kwnames[] = {
36313 (char *) "self",(char *) "orientation", NULL
36314 };
36315
36316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36318 if (!SWIG_IsOK(res1)) {
36319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36320 }
36321 arg1 = reinterpret_cast< wxWindow * >(argp1);
36322 ecode2 = SWIG_AsVal_int(obj1, &val2);
36323 if (!SWIG_IsOK(ecode2)) {
36324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36325 }
36326 arg2 = static_cast< int >(val2);
36327 {
36328 PyThreadState* __tstate = wxPyBeginAllowThreads();
36329 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36330 wxPyEndAllowThreads(__tstate);
36331 if (PyErr_Occurred()) SWIG_fail;
36332 }
36333 resultobj = SWIG_From_int(static_cast< int >(result));
36334 return resultobj;
36335 fail:
36336 return NULL;
36337 }
36338
36339
36340 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36341 PyObject *resultobj = 0;
36342 wxWindow *arg1 = (wxWindow *) 0 ;
36343 int arg2 ;
36344 int result;
36345 void *argp1 = 0 ;
36346 int res1 = 0 ;
36347 int val2 ;
36348 int ecode2 = 0 ;
36349 PyObject * obj0 = 0 ;
36350 PyObject * obj1 = 0 ;
36351 char * kwnames[] = {
36352 (char *) "self",(char *) "orientation", NULL
36353 };
36354
36355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 ecode2 = SWIG_AsVal_int(obj1, &val2);
36362 if (!SWIG_IsOK(ecode2)) {
36363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36364 }
36365 arg2 = static_cast< int >(val2);
36366 {
36367 PyThreadState* __tstate = wxPyBeginAllowThreads();
36368 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36369 wxPyEndAllowThreads(__tstate);
36370 if (PyErr_Occurred()) SWIG_fail;
36371 }
36372 resultobj = SWIG_From_int(static_cast< int >(result));
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj = 0;
36381 wxWindow *arg1 = (wxWindow *) 0 ;
36382 int arg2 ;
36383 int result;
36384 void *argp1 = 0 ;
36385 int res1 = 0 ;
36386 int val2 ;
36387 int ecode2 = 0 ;
36388 PyObject * obj0 = 0 ;
36389 PyObject * obj1 = 0 ;
36390 char * kwnames[] = {
36391 (char *) "self",(char *) "orientation", NULL
36392 };
36393
36394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36396 if (!SWIG_IsOK(res1)) {
36397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36398 }
36399 arg1 = reinterpret_cast< wxWindow * >(argp1);
36400 ecode2 = SWIG_AsVal_int(obj1, &val2);
36401 if (!SWIG_IsOK(ecode2)) {
36402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36403 }
36404 arg2 = static_cast< int >(val2);
36405 {
36406 PyThreadState* __tstate = wxPyBeginAllowThreads();
36407 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36408 wxPyEndAllowThreads(__tstate);
36409 if (PyErr_Occurred()) SWIG_fail;
36410 }
36411 resultobj = SWIG_From_int(static_cast< int >(result));
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 int arg2 ;
36422 int arg3 ;
36423 wxRect *arg4 = (wxRect *) NULL ;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 int val2 ;
36427 int ecode2 = 0 ;
36428 int val3 ;
36429 int ecode3 = 0 ;
36430 void *argp4 = 0 ;
36431 int res4 = 0 ;
36432 PyObject * obj0 = 0 ;
36433 PyObject * obj1 = 0 ;
36434 PyObject * obj2 = 0 ;
36435 PyObject * obj3 = 0 ;
36436 char * kwnames[] = {
36437 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36438 };
36439
36440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_ScrollWindow" "', 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_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36449 }
36450 arg2 = static_cast< int >(val2);
36451 ecode3 = SWIG_AsVal_int(obj2, &val3);
36452 if (!SWIG_IsOK(ecode3)) {
36453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36454 }
36455 arg3 = static_cast< int >(val3);
36456 if (obj3) {
36457 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36458 if (!SWIG_IsOK(res4)) {
36459 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36460 }
36461 arg4 = reinterpret_cast< wxRect * >(argp4);
36462 }
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_Py_Void();
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 int arg2 ;
36480 bool result;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 int val2 ;
36484 int ecode2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "lines", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 ecode2 = SWIG_AsVal_int(obj1, &val2);
36498 if (!SWIG_IsOK(ecode2)) {
36499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36500 }
36501 arg2 = static_cast< int >(val2);
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 result = (bool)(arg1)->ScrollLines(arg2);
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 {
36509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36510 }
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36518 PyObject *resultobj = 0;
36519 wxWindow *arg1 = (wxWindow *) 0 ;
36520 int arg2 ;
36521 bool result;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 int val2 ;
36525 int ecode2 = 0 ;
36526 PyObject * obj0 = 0 ;
36527 PyObject * obj1 = 0 ;
36528 char * kwnames[] = {
36529 (char *) "self",(char *) "pages", NULL
36530 };
36531
36532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36534 if (!SWIG_IsOK(res1)) {
36535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36536 }
36537 arg1 = reinterpret_cast< wxWindow * >(argp1);
36538 ecode2 = SWIG_AsVal_int(obj1, &val2);
36539 if (!SWIG_IsOK(ecode2)) {
36540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36541 }
36542 arg2 = static_cast< int >(val2);
36543 {
36544 PyThreadState* __tstate = wxPyBeginAllowThreads();
36545 result = (bool)(arg1)->ScrollPages(arg2);
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36551 }
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36559 PyObject *resultobj = 0;
36560 wxWindow *arg1 = (wxWindow *) 0 ;
36561 bool result;
36562 void *argp1 = 0 ;
36563 int res1 = 0 ;
36564 PyObject *swig_obj[1] ;
36565
36566 if (!args) SWIG_fail;
36567 swig_obj[0] = args;
36568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36571 }
36572 arg1 = reinterpret_cast< wxWindow * >(argp1);
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (bool)(arg1)->LineUp();
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 {
36580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36581 }
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36589 PyObject *resultobj = 0;
36590 wxWindow *arg1 = (wxWindow *) 0 ;
36591 bool result;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594 PyObject *swig_obj[1] ;
36595
36596 if (!args) SWIG_fail;
36597 swig_obj[0] = args;
36598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res1)) {
36600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36601 }
36602 arg1 = reinterpret_cast< wxWindow * >(argp1);
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 result = (bool)(arg1)->LineDown();
36606 wxPyEndAllowThreads(__tstate);
36607 if (PyErr_Occurred()) SWIG_fail;
36608 }
36609 {
36610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36611 }
36612 return resultobj;
36613 fail:
36614 return NULL;
36615 }
36616
36617
36618 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36619 PyObject *resultobj = 0;
36620 wxWindow *arg1 = (wxWindow *) 0 ;
36621 bool result;
36622 void *argp1 = 0 ;
36623 int res1 = 0 ;
36624 PyObject *swig_obj[1] ;
36625
36626 if (!args) SWIG_fail;
36627 swig_obj[0] = args;
36628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36629 if (!SWIG_IsOK(res1)) {
36630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36631 }
36632 arg1 = reinterpret_cast< wxWindow * >(argp1);
36633 {
36634 PyThreadState* __tstate = wxPyBeginAllowThreads();
36635 result = (bool)(arg1)->PageUp();
36636 wxPyEndAllowThreads(__tstate);
36637 if (PyErr_Occurred()) SWIG_fail;
36638 }
36639 {
36640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36641 }
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36649 PyObject *resultobj = 0;
36650 wxWindow *arg1 = (wxWindow *) 0 ;
36651 bool result;
36652 void *argp1 = 0 ;
36653 int res1 = 0 ;
36654 PyObject *swig_obj[1] ;
36655
36656 if (!args) SWIG_fail;
36657 swig_obj[0] = args;
36658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36659 if (!SWIG_IsOK(res1)) {
36660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36661 }
36662 arg1 = reinterpret_cast< wxWindow * >(argp1);
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 result = (bool)(arg1)->PageDown();
36666 wxPyEndAllowThreads(__tstate);
36667 if (PyErr_Occurred()) SWIG_fail;
36668 }
36669 {
36670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36671 }
36672 return resultobj;
36673 fail:
36674 return NULL;
36675 }
36676
36677
36678 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36679 PyObject *resultobj = 0;
36680 wxWindow *arg1 = (wxWindow *) 0 ;
36681 wxString *arg2 = 0 ;
36682 void *argp1 = 0 ;
36683 int res1 = 0 ;
36684 bool temp2 = false ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "text", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 {
36698 arg2 = wxString_in_helper(obj1);
36699 if (arg2 == NULL) SWIG_fail;
36700 temp2 = true;
36701 }
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 (arg1)->SetHelpText((wxString const &)*arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_Py_Void();
36709 {
36710 if (temp2)
36711 delete arg2;
36712 }
36713 return resultobj;
36714 fail:
36715 {
36716 if (temp2)
36717 delete arg2;
36718 }
36719 return NULL;
36720 }
36721
36722
36723 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj = 0;
36725 wxWindow *arg1 = (wxWindow *) 0 ;
36726 wxString *arg2 = 0 ;
36727 void *argp1 = 0 ;
36728 int res1 = 0 ;
36729 bool temp2 = false ;
36730 PyObject * obj0 = 0 ;
36731 PyObject * obj1 = 0 ;
36732 char * kwnames[] = {
36733 (char *) "self",(char *) "text", NULL
36734 };
36735
36736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36738 if (!SWIG_IsOK(res1)) {
36739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36740 }
36741 arg1 = reinterpret_cast< wxWindow * >(argp1);
36742 {
36743 arg2 = wxString_in_helper(obj1);
36744 if (arg2 == NULL) SWIG_fail;
36745 temp2 = true;
36746 }
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 resultobj = SWIG_Py_Void();
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return resultobj;
36759 fail:
36760 {
36761 if (temp2)
36762 delete arg2;
36763 }
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 wxString result;
36772 void *argp1 = 0 ;
36773 int res1 = 0 ;
36774 PyObject *swig_obj[1] ;
36775
36776 if (!args) SWIG_fail;
36777 swig_obj[0] = args;
36778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36779 if (!SWIG_IsOK(res1)) {
36780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36781 }
36782 arg1 = reinterpret_cast< wxWindow * >(argp1);
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = ((wxWindow const *)arg1)->GetHelpText();
36786 wxPyEndAllowThreads(__tstate);
36787 if (PyErr_Occurred()) SWIG_fail;
36788 }
36789 {
36790 #if wxUSE_UNICODE
36791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36792 #else
36793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36794 #endif
36795 }
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 wxString *arg2 = 0 ;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 bool temp2 = false ;
36809 PyObject * obj0 = 0 ;
36810 PyObject * obj1 = 0 ;
36811 char * kwnames[] = {
36812 (char *) "self",(char *) "tip", NULL
36813 };
36814
36815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36817 if (!SWIG_IsOK(res1)) {
36818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36819 }
36820 arg1 = reinterpret_cast< wxWindow * >(argp1);
36821 {
36822 arg2 = wxString_in_helper(obj1);
36823 if (arg2 == NULL) SWIG_fail;
36824 temp2 = true;
36825 }
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 (arg1)->SetToolTip((wxString const &)*arg2);
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 resultobj = SWIG_Py_Void();
36833 {
36834 if (temp2)
36835 delete arg2;
36836 }
36837 return resultobj;
36838 fail:
36839 {
36840 if (temp2)
36841 delete arg2;
36842 }
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36848 PyObject *resultobj = 0;
36849 wxWindow *arg1 = (wxWindow *) 0 ;
36850 wxToolTip *arg2 = (wxToolTip *) 0 ;
36851 void *argp1 = 0 ;
36852 int res1 = 0 ;
36853 int res2 = 0 ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 char * kwnames[] = {
36857 (char *) "self",(char *) "tip", NULL
36858 };
36859
36860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36867 if (!SWIG_IsOK(res2)) {
36868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36869 }
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 (arg1)->SetToolTip(arg2);
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_Py_Void();
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 wxToolTip *result = 0 ;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 PyObject *swig_obj[1] ;
36890
36891 if (!args) SWIG_fail;
36892 swig_obj[0] = args;
36893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 {
36905 resultobj = wxPyMake_wxObject(result, (bool)0);
36906 }
36907 return resultobj;
36908 fail:
36909 return NULL;
36910 }
36911
36912
36913 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36914 PyObject *resultobj = 0;
36915 wxWindow *arg1 = (wxWindow *) 0 ;
36916 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36917 void *argp1 = 0 ;
36918 int res1 = 0 ;
36919 int res2 = 0 ;
36920 PyObject * obj0 = 0 ;
36921 PyObject * obj1 = 0 ;
36922 char * kwnames[] = {
36923 (char *) "self",(char *) "dropTarget", NULL
36924 };
36925
36926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36928 if (!SWIG_IsOK(res1)) {
36929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36930 }
36931 arg1 = reinterpret_cast< wxWindow * >(argp1);
36932 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36933 if (!SWIG_IsOK(res2)) {
36934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36935 }
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 (arg1)->SetDropTarget(arg2);
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 resultobj = SWIG_Py_Void();
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36950 PyObject *resultobj = 0;
36951 wxWindow *arg1 = (wxWindow *) 0 ;
36952 wxPyDropTarget *result = 0 ;
36953 void *argp1 = 0 ;
36954 int res1 = 0 ;
36955 PyObject *swig_obj[1] ;
36956
36957 if (!args) SWIG_fail;
36958 swig_obj[0] = args;
36959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36960 if (!SWIG_IsOK(res1)) {
36961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36962 }
36963 arg1 = reinterpret_cast< wxWindow * >(argp1);
36964 {
36965 PyThreadState* __tstate = wxPyBeginAllowThreads();
36966 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36978 PyObject *resultobj = 0;
36979 wxWindow *arg1 = (wxWindow *) 0 ;
36980 bool arg2 ;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 bool val2 ;
36984 int ecode2 = 0 ;
36985 PyObject * obj0 = 0 ;
36986 PyObject * obj1 = 0 ;
36987 char * kwnames[] = {
36988 (char *) "self",(char *) "accept", NULL
36989 };
36990
36991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36993 if (!SWIG_IsOK(res1)) {
36994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36995 }
36996 arg1 = reinterpret_cast< wxWindow * >(argp1);
36997 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36998 if (!SWIG_IsOK(ecode2)) {
36999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37000 }
37001 arg2 = static_cast< bool >(val2);
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 wxWindow_DragAcceptFiles(arg1,arg2);
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 resultobj = SWIG_Py_Void();
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37016 PyObject *resultobj = 0;
37017 wxWindow *arg1 = (wxWindow *) 0 ;
37018 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37019 void *argp1 = 0 ;
37020 int res1 = 0 ;
37021 int res2 = 0 ;
37022 PyObject * obj0 = 0 ;
37023 PyObject * obj1 = 0 ;
37024 char * kwnames[] = {
37025 (char *) "self",(char *) "constraints", NULL
37026 };
37027
37028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37030 if (!SWIG_IsOK(res1)) {
37031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37032 }
37033 arg1 = reinterpret_cast< wxWindow * >(argp1);
37034 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37035 if (!SWIG_IsOK(res2)) {
37036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37037 }
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 (arg1)->SetConstraints(arg2);
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 resultobj = SWIG_Py_Void();
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 wxLayoutConstraints *result = 0 ;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 PyObject *swig_obj[1] ;
37058
37059 if (!args) SWIG_fail;
37060 swig_obj[0] = args;
37061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37064 }
37065 arg1 = reinterpret_cast< wxWindow * >(argp1);
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 bool arg2 ;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 bool val2 ;
37086 int ecode2 = 0 ;
37087 PyObject * obj0 = 0 ;
37088 PyObject * obj1 = 0 ;
37089 char * kwnames[] = {
37090 (char *) "self",(char *) "autoLayout", NULL
37091 };
37092
37093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37095 if (!SWIG_IsOK(res1)) {
37096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37097 }
37098 arg1 = reinterpret_cast< wxWindow * >(argp1);
37099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37100 if (!SWIG_IsOK(ecode2)) {
37101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37102 }
37103 arg2 = static_cast< bool >(val2);
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 (arg1)->SetAutoLayout(arg2);
37107 wxPyEndAllowThreads(__tstate);
37108 if (PyErr_Occurred()) SWIG_fail;
37109 }
37110 resultobj = SWIG_Py_Void();
37111 return resultobj;
37112 fail:
37113 return NULL;
37114 }
37115
37116
37117 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37118 PyObject *resultobj = 0;
37119 wxWindow *arg1 = (wxWindow *) 0 ;
37120 bool result;
37121 void *argp1 = 0 ;
37122 int res1 = 0 ;
37123 PyObject *swig_obj[1] ;
37124
37125 if (!args) SWIG_fail;
37126 swig_obj[0] = args;
37127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 {
37133 PyThreadState* __tstate = wxPyBeginAllowThreads();
37134 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 {
37139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37140 }
37141 return resultobj;
37142 fail:
37143 return NULL;
37144 }
37145
37146
37147 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37148 PyObject *resultobj = 0;
37149 wxWindow *arg1 = (wxWindow *) 0 ;
37150 bool result;
37151 void *argp1 = 0 ;
37152 int res1 = 0 ;
37153 PyObject *swig_obj[1] ;
37154
37155 if (!args) SWIG_fail;
37156 swig_obj[0] = args;
37157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37158 if (!SWIG_IsOK(res1)) {
37159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37160 }
37161 arg1 = reinterpret_cast< wxWindow * >(argp1);
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 result = (bool)(arg1)->Layout();
37165 wxPyEndAllowThreads(__tstate);
37166 if (PyErr_Occurred()) SWIG_fail;
37167 }
37168 {
37169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj = 0;
37179 wxWindow *arg1 = (wxWindow *) 0 ;
37180 wxSizer *arg2 = (wxSizer *) 0 ;
37181 bool arg3 = (bool) true ;
37182 void *argp1 = 0 ;
37183 int res1 = 0 ;
37184 int res2 = 0 ;
37185 bool val3 ;
37186 int ecode3 = 0 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 PyObject * obj2 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37198 }
37199 arg1 = reinterpret_cast< wxWindow * >(argp1);
37200 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37201 if (!SWIG_IsOK(res2)) {
37202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37203 }
37204 if (obj2) {
37205 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37206 if (!SWIG_IsOK(ecode3)) {
37207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37208 }
37209 arg3 = static_cast< bool >(val3);
37210 }
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 (arg1)->SetSizer(arg2,arg3);
37214 wxPyEndAllowThreads(__tstate);
37215 if (PyErr_Occurred()) SWIG_fail;
37216 }
37217 resultobj = SWIG_Py_Void();
37218 return resultobj;
37219 fail:
37220 return NULL;
37221 }
37222
37223
37224 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37225 PyObject *resultobj = 0;
37226 wxWindow *arg1 = (wxWindow *) 0 ;
37227 wxSizer *arg2 = (wxSizer *) 0 ;
37228 bool arg3 = (bool) true ;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 int res2 = 0 ;
37232 bool val3 ;
37233 int ecode3 = 0 ;
37234 PyObject * obj0 = 0 ;
37235 PyObject * obj1 = 0 ;
37236 PyObject * obj2 = 0 ;
37237 char * kwnames[] = {
37238 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37239 };
37240
37241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37243 if (!SWIG_IsOK(res1)) {
37244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37245 }
37246 arg1 = reinterpret_cast< wxWindow * >(argp1);
37247 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37248 if (!SWIG_IsOK(res2)) {
37249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37250 }
37251 if (obj2) {
37252 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37253 if (!SWIG_IsOK(ecode3)) {
37254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37255 }
37256 arg3 = static_cast< bool >(val3);
37257 }
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 (arg1)->SetSizerAndFit(arg2,arg3);
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_Py_Void();
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxSizer *result = 0 ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 PyObject *swig_obj[1] ;
37278
37279 if (!args) SWIG_fail;
37280 swig_obj[0] = args;
37281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = wxPyMake_wxObject(result, (bool)0);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 wxSizer *arg2 = (wxSizer *) 0 ;
37305 void *argp1 = 0 ;
37306 int res1 = 0 ;
37307 void *argp2 = 0 ;
37308 int res2 = 0 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char * kwnames[] = {
37312 (char *) "self",(char *) "sizer", NULL
37313 };
37314
37315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37322 if (!SWIG_IsOK(res2)) {
37323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37324 }
37325 arg2 = reinterpret_cast< wxSizer * >(argp2);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 (arg1)->SetContainingSizer(arg2);
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 resultobj = SWIG_Py_Void();
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37340 PyObject *resultobj = 0;
37341 wxWindow *arg1 = (wxWindow *) 0 ;
37342 wxSizer *result = 0 ;
37343 void *argp1 = 0 ;
37344 int res1 = 0 ;
37345 PyObject *swig_obj[1] ;
37346
37347 if (!args) SWIG_fail;
37348 swig_obj[0] = args;
37349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37350 if (!SWIG_IsOK(res1)) {
37351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37352 }
37353 arg1 = reinterpret_cast< wxWindow * >(argp1);
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 {
37361 resultobj = wxPyMake_wxObject(result, (bool)0);
37362 }
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37370 PyObject *resultobj = 0;
37371 wxWindow *arg1 = (wxWindow *) 0 ;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 PyObject *swig_obj[1] ;
37375
37376 if (!args) SWIG_fail;
37377 swig_obj[0] = args;
37378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->InheritAttributes();
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_Py_Void();
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 bool result;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 PyObject *swig_obj[1] ;
37403
37404 if (!args) SWIG_fail;
37405 swig_obj[0] = args;
37406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37407 if (!SWIG_IsOK(res1)) {
37408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37409 }
37410 arg1 = reinterpret_cast< wxWindow * >(argp1);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 {
37418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37419 }
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37427 PyObject *obj;
37428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37429 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37430 return SWIG_Py_Void();
37431 }
37432
37433 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37434 return SWIG_Python_InitShadowInstance(args);
37435 }
37436
37437 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37438 PyObject *resultobj = 0;
37439 long arg1 ;
37440 wxWindow *arg2 = (wxWindow *) NULL ;
37441 wxWindow *result = 0 ;
37442 long val1 ;
37443 int ecode1 = 0 ;
37444 void *argp2 = 0 ;
37445 int res2 = 0 ;
37446 PyObject * obj0 = 0 ;
37447 PyObject * obj1 = 0 ;
37448 char * kwnames[] = {
37449 (char *) "id",(char *) "parent", NULL
37450 };
37451
37452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37453 ecode1 = SWIG_AsVal_long(obj0, &val1);
37454 if (!SWIG_IsOK(ecode1)) {
37455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37456 }
37457 arg1 = static_cast< long >(val1);
37458 if (obj1) {
37459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37460 if (!SWIG_IsOK(res2)) {
37461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37462 }
37463 arg2 = reinterpret_cast< wxWindow * >(argp2);
37464 }
37465 {
37466 if (!wxPyCheckForApp()) SWIG_fail;
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 {
37473 resultobj = wxPyMake_wxObject(result, 0);
37474 }
37475 return resultobj;
37476 fail:
37477 return NULL;
37478 }
37479
37480
37481 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37482 PyObject *resultobj = 0;
37483 wxString *arg1 = 0 ;
37484 wxWindow *arg2 = (wxWindow *) NULL ;
37485 wxWindow *result = 0 ;
37486 bool temp1 = false ;
37487 void *argp2 = 0 ;
37488 int res2 = 0 ;
37489 PyObject * obj0 = 0 ;
37490 PyObject * obj1 = 0 ;
37491 char * kwnames[] = {
37492 (char *) "name",(char *) "parent", NULL
37493 };
37494
37495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37496 {
37497 arg1 = wxString_in_helper(obj0);
37498 if (arg1 == NULL) SWIG_fail;
37499 temp1 = true;
37500 }
37501 if (obj1) {
37502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37503 if (!SWIG_IsOK(res2)) {
37504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37505 }
37506 arg2 = reinterpret_cast< wxWindow * >(argp2);
37507 }
37508 {
37509 if (!wxPyCheckForApp()) SWIG_fail;
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 {
37516 resultobj = wxPyMake_wxObject(result, 0);
37517 }
37518 {
37519 if (temp1)
37520 delete arg1;
37521 }
37522 return resultobj;
37523 fail:
37524 {
37525 if (temp1)
37526 delete arg1;
37527 }
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37533 PyObject *resultobj = 0;
37534 wxString *arg1 = 0 ;
37535 wxWindow *arg2 = (wxWindow *) NULL ;
37536 wxWindow *result = 0 ;
37537 bool temp1 = false ;
37538 void *argp2 = 0 ;
37539 int res2 = 0 ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 char * kwnames[] = {
37543 (char *) "label",(char *) "parent", NULL
37544 };
37545
37546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37547 {
37548 arg1 = wxString_in_helper(obj0);
37549 if (arg1 == NULL) SWIG_fail;
37550 temp1 = true;
37551 }
37552 if (obj1) {
37553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res2)) {
37555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37556 }
37557 arg2 = reinterpret_cast< wxWindow * >(argp2);
37558 }
37559 {
37560 if (!wxPyCheckForApp()) SWIG_fail;
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37563 wxPyEndAllowThreads(__tstate);
37564 if (PyErr_Occurred()) SWIG_fail;
37565 }
37566 {
37567 resultobj = wxPyMake_wxObject(result, 0);
37568 }
37569 {
37570 if (temp1)
37571 delete arg1;
37572 }
37573 return resultobj;
37574 fail:
37575 {
37576 if (temp1)
37577 delete arg1;
37578 }
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = 0;
37585 wxWindow *arg1 = (wxWindow *) 0 ;
37586 unsigned long arg2 ;
37587 wxWindow *result = 0 ;
37588 void *argp1 = 0 ;
37589 int res1 = 0 ;
37590 unsigned long val2 ;
37591 int ecode2 = 0 ;
37592 PyObject * obj0 = 0 ;
37593 PyObject * obj1 = 0 ;
37594 char * kwnames[] = {
37595 (char *) "parent",(char *) "_hWnd", NULL
37596 };
37597
37598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37600 if (!SWIG_IsOK(res1)) {
37601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37602 }
37603 arg1 = reinterpret_cast< wxWindow * >(argp1);
37604 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37605 if (!SWIG_IsOK(ecode2)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37607 }
37608 arg2 = static_cast< unsigned long >(val2);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 {
37616 resultobj = wxPyMake_wxObject(result, 0);
37617 }
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37625 PyObject *resultobj = 0;
37626 PyObject *result = 0 ;
37627
37628 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = (PyObject *)GetTopLevelWindows();
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = result;
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37643 PyObject *resultobj = 0;
37644 wxValidator *result = 0 ;
37645
37646 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (wxValidator *)new wxValidator();
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37661 PyObject *resultobj = 0;
37662 wxValidator *arg1 = (wxValidator *) 0 ;
37663 wxValidator *result = 0 ;
37664 void *argp1 = 0 ;
37665 int res1 = 0 ;
37666 PyObject *swig_obj[1] ;
37667
37668 if (!args) SWIG_fail;
37669 swig_obj[0] = args;
37670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37671 if (!SWIG_IsOK(res1)) {
37672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37673 }
37674 arg1 = reinterpret_cast< wxValidator * >(argp1);
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 result = (wxValidator *)(arg1)->Clone();
37678 wxPyEndAllowThreads(__tstate);
37679 if (PyErr_Occurred()) SWIG_fail;
37680 }
37681 {
37682 resultobj = wxPyMake_wxObject(result, 0);
37683 }
37684 return resultobj;
37685 fail:
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37691 PyObject *resultobj = 0;
37692 wxValidator *arg1 = (wxValidator *) 0 ;
37693 wxWindow *arg2 = (wxWindow *) 0 ;
37694 bool result;
37695 void *argp1 = 0 ;
37696 int res1 = 0 ;
37697 void *argp2 = 0 ;
37698 int res2 = 0 ;
37699 PyObject * obj0 = 0 ;
37700 PyObject * obj1 = 0 ;
37701 char * kwnames[] = {
37702 (char *) "self",(char *) "parent", NULL
37703 };
37704
37705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37707 if (!SWIG_IsOK(res1)) {
37708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37709 }
37710 arg1 = reinterpret_cast< wxValidator * >(argp1);
37711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37712 if (!SWIG_IsOK(res2)) {
37713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37714 }
37715 arg2 = reinterpret_cast< wxWindow * >(argp2);
37716 {
37717 PyThreadState* __tstate = wxPyBeginAllowThreads();
37718 result = (bool)(arg1)->Validate(arg2);
37719 wxPyEndAllowThreads(__tstate);
37720 if (PyErr_Occurred()) SWIG_fail;
37721 }
37722 {
37723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37724 }
37725 return resultobj;
37726 fail:
37727 return NULL;
37728 }
37729
37730
37731 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37732 PyObject *resultobj = 0;
37733 wxValidator *arg1 = (wxValidator *) 0 ;
37734 bool result;
37735 void *argp1 = 0 ;
37736 int res1 = 0 ;
37737 PyObject *swig_obj[1] ;
37738
37739 if (!args) SWIG_fail;
37740 swig_obj[0] = args;
37741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37742 if (!SWIG_IsOK(res1)) {
37743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37744 }
37745 arg1 = reinterpret_cast< wxValidator * >(argp1);
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 result = (bool)(arg1)->TransferToWindow();
37749 wxPyEndAllowThreads(__tstate);
37750 if (PyErr_Occurred()) SWIG_fail;
37751 }
37752 {
37753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37754 }
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 PyObject *resultobj = 0;
37763 wxValidator *arg1 = (wxValidator *) 0 ;
37764 bool result;
37765 void *argp1 = 0 ;
37766 int res1 = 0 ;
37767 PyObject *swig_obj[1] ;
37768
37769 if (!args) SWIG_fail;
37770 swig_obj[0] = args;
37771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37772 if (!SWIG_IsOK(res1)) {
37773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37774 }
37775 arg1 = reinterpret_cast< wxValidator * >(argp1);
37776 {
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (bool)(arg1)->TransferFromWindow();
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37784 }
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37792 PyObject *resultobj = 0;
37793 wxValidator *arg1 = (wxValidator *) 0 ;
37794 wxWindow *result = 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37804 }
37805 arg1 = reinterpret_cast< wxValidator * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (wxWindow *)(arg1)->GetWindow();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 {
37813 resultobj = wxPyMake_wxObject(result, 0);
37814 }
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37822 PyObject *resultobj = 0;
37823 wxValidator *arg1 = (wxValidator *) 0 ;
37824 wxWindow *arg2 = (wxWindow *) 0 ;
37825 void *argp1 = 0 ;
37826 int res1 = 0 ;
37827 void *argp2 = 0 ;
37828 int res2 = 0 ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char * kwnames[] = {
37832 (char *) "self",(char *) "window", NULL
37833 };
37834
37835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37839 }
37840 arg1 = reinterpret_cast< wxValidator * >(argp1);
37841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37842 if (!SWIG_IsOK(res2)) {
37843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37844 }
37845 arg2 = reinterpret_cast< wxWindow * >(argp2);
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 (arg1)->SetWindow(arg2);
37849 wxPyEndAllowThreads(__tstate);
37850 if (PyErr_Occurred()) SWIG_fail;
37851 }
37852 resultobj = SWIG_Py_Void();
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37860 PyObject *resultobj = 0;
37861 bool result;
37862
37863 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 result = (bool)wxValidator::IsSilent();
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 {
37871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37872 }
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37880 PyObject *resultobj = 0;
37881 int arg1 = (int) true ;
37882 int val1 ;
37883 int ecode1 = 0 ;
37884 PyObject * obj0 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "doIt", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37890 if (obj0) {
37891 ecode1 = SWIG_AsVal_int(obj0, &val1);
37892 if (!SWIG_IsOK(ecode1)) {
37893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37894 }
37895 arg1 = static_cast< int >(val1);
37896 }
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 wxValidator::SetBellOnError(arg1);
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 resultobj = SWIG_Py_Void();
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *obj;
37912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37913 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37914 return SWIG_Py_Void();
37915 }
37916
37917 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 return SWIG_Python_InitShadowInstance(args);
37919 }
37920
37921 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxPyValidator *result = 0 ;
37924
37925 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (wxPyValidator *)new wxPyValidator();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37942 PyObject *arg2 = (PyObject *) 0 ;
37943 PyObject *arg3 = (PyObject *) 0 ;
37944 int arg4 = (int) true ;
37945 void *argp1 = 0 ;
37946 int res1 = 0 ;
37947 int val4 ;
37948 int ecode4 = 0 ;
37949 PyObject * obj0 = 0 ;
37950 PyObject * obj1 = 0 ;
37951 PyObject * obj2 = 0 ;
37952 PyObject * obj3 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37959 if (!SWIG_IsOK(res1)) {
37960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37961 }
37962 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37963 arg2 = obj1;
37964 arg3 = obj2;
37965 if (obj3) {
37966 ecode4 = SWIG_AsVal_int(obj3, &val4);
37967 if (!SWIG_IsOK(ecode4)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37969 }
37970 arg4 = static_cast< int >(val4);
37971 }
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 resultobj = SWIG_Py_Void();
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37986 PyObject *obj;
37987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37989 return SWIG_Py_Void();
37990 }
37991
37992 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37993 return SWIG_Python_InitShadowInstance(args);
37994 }
37995
37996 SWIGINTERN int DefaultValidator_set(PyObject *) {
37997 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37998 return 1;
37999 }
38000
38001
38002 SWIGINTERN PyObject *DefaultValidator_get(void) {
38003 PyObject *pyobj = 0;
38004
38005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38006 return pyobj;
38007 }
38008
38009
38010 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38011 PyObject *resultobj = 0;
38012 wxString const &arg1_defvalue = wxPyEmptyString ;
38013 wxString *arg1 = (wxString *) &arg1_defvalue ;
38014 long arg2 = (long) 0 ;
38015 wxMenu *result = 0 ;
38016 bool temp1 = false ;
38017 long val2 ;
38018 int ecode2 = 0 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 char * kwnames[] = {
38022 (char *) "title",(char *) "style", NULL
38023 };
38024
38025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38026 if (obj0) {
38027 {
38028 arg1 = wxString_in_helper(obj0);
38029 if (arg1 == NULL) SWIG_fail;
38030 temp1 = true;
38031 }
38032 }
38033 if (obj1) {
38034 ecode2 = SWIG_AsVal_long(obj1, &val2);
38035 if (!SWIG_IsOK(ecode2)) {
38036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38037 }
38038 arg2 = static_cast< long >(val2);
38039 }
38040 {
38041 if (!wxPyCheckForApp()) SWIG_fail;
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38044 wxPyEndAllowThreads(__tstate);
38045 if (PyErr_Occurred()) SWIG_fail;
38046 }
38047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38048 {
38049 if (temp1)
38050 delete arg1;
38051 }
38052 return resultobj;
38053 fail:
38054 {
38055 if (temp1)
38056 delete arg1;
38057 }
38058 return NULL;
38059 }
38060
38061
38062 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38063 PyObject *resultobj = 0;
38064 wxMenu *arg1 = (wxMenu *) 0 ;
38065 int arg2 ;
38066 wxString *arg3 = 0 ;
38067 wxString const &arg4_defvalue = wxPyEmptyString ;
38068 wxString *arg4 = (wxString *) &arg4_defvalue ;
38069 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38070 wxMenuItem *result = 0 ;
38071 void *argp1 = 0 ;
38072 int res1 = 0 ;
38073 int val2 ;
38074 int ecode2 = 0 ;
38075 bool temp3 = false ;
38076 bool temp4 = false ;
38077 int val5 ;
38078 int ecode5 = 0 ;
38079 PyObject * obj0 = 0 ;
38080 PyObject * obj1 = 0 ;
38081 PyObject * obj2 = 0 ;
38082 PyObject * obj3 = 0 ;
38083 PyObject * obj4 = 0 ;
38084 char * kwnames[] = {
38085 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38086 };
38087
38088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38090 if (!SWIG_IsOK(res1)) {
38091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38092 }
38093 arg1 = reinterpret_cast< wxMenu * >(argp1);
38094 ecode2 = SWIG_AsVal_int(obj1, &val2);
38095 if (!SWIG_IsOK(ecode2)) {
38096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38097 }
38098 arg2 = static_cast< int >(val2);
38099 {
38100 arg3 = wxString_in_helper(obj2);
38101 if (arg3 == NULL) SWIG_fail;
38102 temp3 = true;
38103 }
38104 if (obj3) {
38105 {
38106 arg4 = wxString_in_helper(obj3);
38107 if (arg4 == NULL) SWIG_fail;
38108 temp4 = true;
38109 }
38110 }
38111 if (obj4) {
38112 ecode5 = SWIG_AsVal_int(obj4, &val5);
38113 if (!SWIG_IsOK(ecode5)) {
38114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38115 }
38116 arg5 = static_cast< wxItemKind >(val5);
38117 }
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 {
38125 resultobj = wxPyMake_wxObject(result, (bool)0);
38126 }
38127 {
38128 if (temp3)
38129 delete arg3;
38130 }
38131 {
38132 if (temp4)
38133 delete arg4;
38134 }
38135 return resultobj;
38136 fail:
38137 {
38138 if (temp3)
38139 delete arg3;
38140 }
38141 {
38142 if (temp4)
38143 delete arg4;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 PyObject *resultobj = 0;
38151 wxMenu *arg1 = (wxMenu *) 0 ;
38152 wxMenuItem *result = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38162 }
38163 arg1 = reinterpret_cast< wxMenu * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 result = (wxMenuItem *)(arg1)->AppendSeparator();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = wxPyMake_wxObject(result, (bool)0);
38172 }
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj = 0;
38181 wxMenu *arg1 = (wxMenu *) 0 ;
38182 int arg2 ;
38183 wxString *arg3 = 0 ;
38184 wxString const &arg4_defvalue = wxPyEmptyString ;
38185 wxString *arg4 = (wxString *) &arg4_defvalue ;
38186 wxMenuItem *result = 0 ;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 int val2 ;
38190 int ecode2 = 0 ;
38191 bool temp3 = false ;
38192 bool temp4 = false ;
38193 PyObject * obj0 = 0 ;
38194 PyObject * obj1 = 0 ;
38195 PyObject * obj2 = 0 ;
38196 PyObject * obj3 = 0 ;
38197 char * kwnames[] = {
38198 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38199 };
38200
38201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38203 if (!SWIG_IsOK(res1)) {
38204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38205 }
38206 arg1 = reinterpret_cast< wxMenu * >(argp1);
38207 ecode2 = SWIG_AsVal_int(obj1, &val2);
38208 if (!SWIG_IsOK(ecode2)) {
38209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38210 }
38211 arg2 = static_cast< int >(val2);
38212 {
38213 arg3 = wxString_in_helper(obj2);
38214 if (arg3 == NULL) SWIG_fail;
38215 temp3 = true;
38216 }
38217 if (obj3) {
38218 {
38219 arg4 = wxString_in_helper(obj3);
38220 if (arg4 == NULL) SWIG_fail;
38221 temp4 = true;
38222 }
38223 }
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 {
38231 resultobj = wxPyMake_wxObject(result, (bool)0);
38232 }
38233 {
38234 if (temp3)
38235 delete arg3;
38236 }
38237 {
38238 if (temp4)
38239 delete arg4;
38240 }
38241 return resultobj;
38242 fail:
38243 {
38244 if (temp3)
38245 delete arg3;
38246 }
38247 {
38248 if (temp4)
38249 delete arg4;
38250 }
38251 return NULL;
38252 }
38253
38254
38255 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38256 PyObject *resultobj = 0;
38257 wxMenu *arg1 = (wxMenu *) 0 ;
38258 int arg2 ;
38259 wxString *arg3 = 0 ;
38260 wxString const &arg4_defvalue = wxPyEmptyString ;
38261 wxString *arg4 = (wxString *) &arg4_defvalue ;
38262 wxMenuItem *result = 0 ;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 int val2 ;
38266 int ecode2 = 0 ;
38267 bool temp3 = false ;
38268 bool temp4 = false ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 PyObject * obj2 = 0 ;
38272 PyObject * obj3 = 0 ;
38273 char * kwnames[] = {
38274 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38275 };
38276
38277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38279 if (!SWIG_IsOK(res1)) {
38280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38281 }
38282 arg1 = reinterpret_cast< wxMenu * >(argp1);
38283 ecode2 = SWIG_AsVal_int(obj1, &val2);
38284 if (!SWIG_IsOK(ecode2)) {
38285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38286 }
38287 arg2 = static_cast< int >(val2);
38288 {
38289 arg3 = wxString_in_helper(obj2);
38290 if (arg3 == NULL) SWIG_fail;
38291 temp3 = true;
38292 }
38293 if (obj3) {
38294 {
38295 arg4 = wxString_in_helper(obj3);
38296 if (arg4 == NULL) SWIG_fail;
38297 temp4 = true;
38298 }
38299 }
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38303 wxPyEndAllowThreads(__tstate);
38304 if (PyErr_Occurred()) SWIG_fail;
38305 }
38306 {
38307 resultobj = wxPyMake_wxObject(result, (bool)0);
38308 }
38309 {
38310 if (temp3)
38311 delete arg3;
38312 }
38313 {
38314 if (temp4)
38315 delete arg4;
38316 }
38317 return resultobj;
38318 fail:
38319 {
38320 if (temp3)
38321 delete arg3;
38322 }
38323 {
38324 if (temp4)
38325 delete arg4;
38326 }
38327 return NULL;
38328 }
38329
38330
38331 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38332 PyObject *resultobj = 0;
38333 wxMenu *arg1 = (wxMenu *) 0 ;
38334 int arg2 ;
38335 wxString *arg3 = 0 ;
38336 wxMenu *arg4 = (wxMenu *) 0 ;
38337 wxString const &arg5_defvalue = wxPyEmptyString ;
38338 wxString *arg5 = (wxString *) &arg5_defvalue ;
38339 wxMenuItem *result = 0 ;
38340 void *argp1 = 0 ;
38341 int res1 = 0 ;
38342 int val2 ;
38343 int ecode2 = 0 ;
38344 bool temp3 = false ;
38345 void *argp4 = 0 ;
38346 int res4 = 0 ;
38347 bool temp5 = false ;
38348 PyObject * obj0 = 0 ;
38349 PyObject * obj1 = 0 ;
38350 PyObject * obj2 = 0 ;
38351 PyObject * obj3 = 0 ;
38352 PyObject * obj4 = 0 ;
38353 char * kwnames[] = {
38354 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38355 };
38356
38357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38359 if (!SWIG_IsOK(res1)) {
38360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38361 }
38362 arg1 = reinterpret_cast< wxMenu * >(argp1);
38363 ecode2 = SWIG_AsVal_int(obj1, &val2);
38364 if (!SWIG_IsOK(ecode2)) {
38365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38366 }
38367 arg2 = static_cast< int >(val2);
38368 {
38369 arg3 = wxString_in_helper(obj2);
38370 if (arg3 == NULL) SWIG_fail;
38371 temp3 = true;
38372 }
38373 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38374 if (!SWIG_IsOK(res4)) {
38375 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38376 }
38377 arg4 = reinterpret_cast< wxMenu * >(argp4);
38378 if (obj4) {
38379 {
38380 arg5 = wxString_in_helper(obj4);
38381 if (arg5 == NULL) SWIG_fail;
38382 temp5 = true;
38383 }
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 {
38392 resultobj = wxPyMake_wxObject(result, (bool)0);
38393 }
38394 {
38395 if (temp3)
38396 delete arg3;
38397 }
38398 {
38399 if (temp5)
38400 delete arg5;
38401 }
38402 return resultobj;
38403 fail:
38404 {
38405 if (temp3)
38406 delete arg3;
38407 }
38408 {
38409 if (temp5)
38410 delete arg5;
38411 }
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38417 PyObject *resultobj = 0;
38418 wxMenu *arg1 = (wxMenu *) 0 ;
38419 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38420 wxMenuItem *result = 0 ;
38421 void *argp1 = 0 ;
38422 int res1 = 0 ;
38423 int res2 = 0 ;
38424 PyObject * obj0 = 0 ;
38425 PyObject * obj1 = 0 ;
38426 char * kwnames[] = {
38427 (char *) "self",(char *) "item", NULL
38428 };
38429
38430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38432 if (!SWIG_IsOK(res1)) {
38433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38434 }
38435 arg1 = reinterpret_cast< wxMenu * >(argp1);
38436 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38437 if (!SWIG_IsOK(res2)) {
38438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38439 }
38440 {
38441 PyThreadState* __tstate = wxPyBeginAllowThreads();
38442 result = (wxMenuItem *)(arg1)->Append(arg2);
38443 wxPyEndAllowThreads(__tstate);
38444 if (PyErr_Occurred()) SWIG_fail;
38445 }
38446 {
38447 resultobj = wxPyMake_wxObject(result, (bool)0);
38448 }
38449 return resultobj;
38450 fail:
38451 return NULL;
38452 }
38453
38454
38455 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38456 PyObject *resultobj = 0;
38457 wxMenu *arg1 = (wxMenu *) 0 ;
38458 size_t arg2 ;
38459 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38460 wxMenuItem *result = 0 ;
38461 void *argp1 = 0 ;
38462 int res1 = 0 ;
38463 size_t val2 ;
38464 int ecode2 = 0 ;
38465 int res3 = 0 ;
38466 PyObject * obj0 = 0 ;
38467 PyObject * obj1 = 0 ;
38468 PyObject * obj2 = 0 ;
38469 char * kwnames[] = {
38470 (char *) "self",(char *) "pos",(char *) "item", NULL
38471 };
38472
38473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38477 }
38478 arg1 = reinterpret_cast< wxMenu * >(argp1);
38479 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38480 if (!SWIG_IsOK(ecode2)) {
38481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38482 }
38483 arg2 = static_cast< size_t >(val2);
38484 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38485 if (!SWIG_IsOK(res3)) {
38486 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38487 }
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = wxPyMake_wxObject(result, (bool)0);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxMenu *arg1 = (wxMenu *) 0 ;
38506 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38507 wxMenuItem *result = 0 ;
38508 void *argp1 = 0 ;
38509 int res1 = 0 ;
38510 int res2 = 0 ;
38511 PyObject * obj0 = 0 ;
38512 PyObject * obj1 = 0 ;
38513 char * kwnames[] = {
38514 (char *) "self",(char *) "item", NULL
38515 };
38516
38517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38519 if (!SWIG_IsOK(res1)) {
38520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38521 }
38522 arg1 = reinterpret_cast< wxMenu * >(argp1);
38523 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38524 if (!SWIG_IsOK(res2)) {
38525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 {
38534 resultobj = wxPyMake_wxObject(result, (bool)0);
38535 }
38536 return resultobj;
38537 fail:
38538 return NULL;
38539 }
38540
38541
38542 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38543 PyObject *resultobj = 0;
38544 wxMenu *arg1 = (wxMenu *) 0 ;
38545 void *argp1 = 0 ;
38546 int res1 = 0 ;
38547 PyObject *swig_obj[1] ;
38548
38549 if (!args) SWIG_fail;
38550 swig_obj[0] = args;
38551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38552 if (!SWIG_IsOK(res1)) {
38553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38554 }
38555 arg1 = reinterpret_cast< wxMenu * >(argp1);
38556 {
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 (arg1)->Break();
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 resultobj = SWIG_Py_Void();
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38570 PyObject *resultobj = 0;
38571 wxMenu *arg1 = (wxMenu *) 0 ;
38572 size_t arg2 ;
38573 int arg3 ;
38574 wxString *arg4 = 0 ;
38575 wxString const &arg5_defvalue = wxPyEmptyString ;
38576 wxString *arg5 = (wxString *) &arg5_defvalue ;
38577 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38578 wxMenuItem *result = 0 ;
38579 void *argp1 = 0 ;
38580 int res1 = 0 ;
38581 size_t val2 ;
38582 int ecode2 = 0 ;
38583 int val3 ;
38584 int ecode3 = 0 ;
38585 bool temp4 = false ;
38586 bool temp5 = false ;
38587 int val6 ;
38588 int ecode6 = 0 ;
38589 PyObject * obj0 = 0 ;
38590 PyObject * obj1 = 0 ;
38591 PyObject * obj2 = 0 ;
38592 PyObject * obj3 = 0 ;
38593 PyObject * obj4 = 0 ;
38594 PyObject * obj5 = 0 ;
38595 char * kwnames[] = {
38596 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38597 };
38598
38599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38601 if (!SWIG_IsOK(res1)) {
38602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38603 }
38604 arg1 = reinterpret_cast< wxMenu * >(argp1);
38605 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38606 if (!SWIG_IsOK(ecode2)) {
38607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38608 }
38609 arg2 = static_cast< size_t >(val2);
38610 ecode3 = SWIG_AsVal_int(obj2, &val3);
38611 if (!SWIG_IsOK(ecode3)) {
38612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38613 }
38614 arg3 = static_cast< int >(val3);
38615 {
38616 arg4 = wxString_in_helper(obj3);
38617 if (arg4 == NULL) SWIG_fail;
38618 temp4 = true;
38619 }
38620 if (obj4) {
38621 {
38622 arg5 = wxString_in_helper(obj4);
38623 if (arg5 == NULL) SWIG_fail;
38624 temp5 = true;
38625 }
38626 }
38627 if (obj5) {
38628 ecode6 = SWIG_AsVal_int(obj5, &val6);
38629 if (!SWIG_IsOK(ecode6)) {
38630 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38631 }
38632 arg6 = static_cast< wxItemKind >(val6);
38633 }
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38637 wxPyEndAllowThreads(__tstate);
38638 if (PyErr_Occurred()) SWIG_fail;
38639 }
38640 {
38641 resultobj = wxPyMake_wxObject(result, (bool)0);
38642 }
38643 {
38644 if (temp4)
38645 delete arg4;
38646 }
38647 {
38648 if (temp5)
38649 delete arg5;
38650 }
38651 return resultobj;
38652 fail:
38653 {
38654 if (temp4)
38655 delete arg4;
38656 }
38657 {
38658 if (temp5)
38659 delete arg5;
38660 }
38661 return NULL;
38662 }
38663
38664
38665 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38666 PyObject *resultobj = 0;
38667 wxMenu *arg1 = (wxMenu *) 0 ;
38668 size_t arg2 ;
38669 wxMenuItem *result = 0 ;
38670 void *argp1 = 0 ;
38671 int res1 = 0 ;
38672 size_t val2 ;
38673 int ecode2 = 0 ;
38674 PyObject * obj0 = 0 ;
38675 PyObject * obj1 = 0 ;
38676 char * kwnames[] = {
38677 (char *) "self",(char *) "pos", NULL
38678 };
38679
38680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38684 }
38685 arg1 = reinterpret_cast< wxMenu * >(argp1);
38686 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38687 if (!SWIG_IsOK(ecode2)) {
38688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38689 }
38690 arg2 = static_cast< size_t >(val2);
38691 {
38692 PyThreadState* __tstate = wxPyBeginAllowThreads();
38693 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38694 wxPyEndAllowThreads(__tstate);
38695 if (PyErr_Occurred()) SWIG_fail;
38696 }
38697 {
38698 resultobj = wxPyMake_wxObject(result, (bool)0);
38699 }
38700 return resultobj;
38701 fail:
38702 return NULL;
38703 }
38704
38705
38706 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38707 PyObject *resultobj = 0;
38708 wxMenu *arg1 = (wxMenu *) 0 ;
38709 size_t arg2 ;
38710 int arg3 ;
38711 wxString *arg4 = 0 ;
38712 wxString const &arg5_defvalue = wxPyEmptyString ;
38713 wxString *arg5 = (wxString *) &arg5_defvalue ;
38714 wxMenuItem *result = 0 ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 size_t val2 ;
38718 int ecode2 = 0 ;
38719 int val3 ;
38720 int ecode3 = 0 ;
38721 bool temp4 = false ;
38722 bool temp5 = false ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 PyObject * obj2 = 0 ;
38726 PyObject * obj3 = 0 ;
38727 PyObject * obj4 = 0 ;
38728 char * kwnames[] = {
38729 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38730 };
38731
38732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38734 if (!SWIG_IsOK(res1)) {
38735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38736 }
38737 arg1 = reinterpret_cast< wxMenu * >(argp1);
38738 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38739 if (!SWIG_IsOK(ecode2)) {
38740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38741 }
38742 arg2 = static_cast< size_t >(val2);
38743 ecode3 = SWIG_AsVal_int(obj2, &val3);
38744 if (!SWIG_IsOK(ecode3)) {
38745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38746 }
38747 arg3 = static_cast< int >(val3);
38748 {
38749 arg4 = wxString_in_helper(obj3);
38750 if (arg4 == NULL) SWIG_fail;
38751 temp4 = true;
38752 }
38753 if (obj4) {
38754 {
38755 arg5 = wxString_in_helper(obj4);
38756 if (arg5 == NULL) SWIG_fail;
38757 temp5 = true;
38758 }
38759 }
38760 {
38761 PyThreadState* __tstate = wxPyBeginAllowThreads();
38762 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 {
38767 resultobj = wxPyMake_wxObject(result, (bool)0);
38768 }
38769 {
38770 if (temp4)
38771 delete arg4;
38772 }
38773 {
38774 if (temp5)
38775 delete arg5;
38776 }
38777 return resultobj;
38778 fail:
38779 {
38780 if (temp4)
38781 delete arg4;
38782 }
38783 {
38784 if (temp5)
38785 delete arg5;
38786 }
38787 return NULL;
38788 }
38789
38790
38791 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38792 PyObject *resultobj = 0;
38793 wxMenu *arg1 = (wxMenu *) 0 ;
38794 size_t arg2 ;
38795 int arg3 ;
38796 wxString *arg4 = 0 ;
38797 wxString const &arg5_defvalue = wxPyEmptyString ;
38798 wxString *arg5 = (wxString *) &arg5_defvalue ;
38799 wxMenuItem *result = 0 ;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 size_t val2 ;
38803 int ecode2 = 0 ;
38804 int val3 ;
38805 int ecode3 = 0 ;
38806 bool temp4 = false ;
38807 bool temp5 = false ;
38808 PyObject * obj0 = 0 ;
38809 PyObject * obj1 = 0 ;
38810 PyObject * obj2 = 0 ;
38811 PyObject * obj3 = 0 ;
38812 PyObject * obj4 = 0 ;
38813 char * kwnames[] = {
38814 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38815 };
38816
38817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38821 }
38822 arg1 = reinterpret_cast< wxMenu * >(argp1);
38823 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38824 if (!SWIG_IsOK(ecode2)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38826 }
38827 arg2 = static_cast< size_t >(val2);
38828 ecode3 = SWIG_AsVal_int(obj2, &val3);
38829 if (!SWIG_IsOK(ecode3)) {
38830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38831 }
38832 arg3 = static_cast< int >(val3);
38833 {
38834 arg4 = wxString_in_helper(obj3);
38835 if (arg4 == NULL) SWIG_fail;
38836 temp4 = true;
38837 }
38838 if (obj4) {
38839 {
38840 arg5 = wxString_in_helper(obj4);
38841 if (arg5 == NULL) SWIG_fail;
38842 temp5 = true;
38843 }
38844 }
38845 {
38846 PyThreadState* __tstate = wxPyBeginAllowThreads();
38847 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38848 wxPyEndAllowThreads(__tstate);
38849 if (PyErr_Occurred()) SWIG_fail;
38850 }
38851 {
38852 resultobj = wxPyMake_wxObject(result, (bool)0);
38853 }
38854 {
38855 if (temp4)
38856 delete arg4;
38857 }
38858 {
38859 if (temp5)
38860 delete arg5;
38861 }
38862 return resultobj;
38863 fail:
38864 {
38865 if (temp4)
38866 delete arg4;
38867 }
38868 {
38869 if (temp5)
38870 delete arg5;
38871 }
38872 return NULL;
38873 }
38874
38875
38876 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = 0;
38878 wxMenu *arg1 = (wxMenu *) 0 ;
38879 size_t arg2 ;
38880 int arg3 ;
38881 wxString *arg4 = 0 ;
38882 wxMenu *arg5 = (wxMenu *) 0 ;
38883 wxString const &arg6_defvalue = wxPyEmptyString ;
38884 wxString *arg6 = (wxString *) &arg6_defvalue ;
38885 wxMenuItem *result = 0 ;
38886 void *argp1 = 0 ;
38887 int res1 = 0 ;
38888 size_t val2 ;
38889 int ecode2 = 0 ;
38890 int val3 ;
38891 int ecode3 = 0 ;
38892 bool temp4 = false ;
38893 void *argp5 = 0 ;
38894 int res5 = 0 ;
38895 bool temp6 = false ;
38896 PyObject * obj0 = 0 ;
38897 PyObject * obj1 = 0 ;
38898 PyObject * obj2 = 0 ;
38899 PyObject * obj3 = 0 ;
38900 PyObject * obj4 = 0 ;
38901 PyObject * obj5 = 0 ;
38902 char * kwnames[] = {
38903 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38904 };
38905
38906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38908 if (!SWIG_IsOK(res1)) {
38909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38910 }
38911 arg1 = reinterpret_cast< wxMenu * >(argp1);
38912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38913 if (!SWIG_IsOK(ecode2)) {
38914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38915 }
38916 arg2 = static_cast< size_t >(val2);
38917 ecode3 = SWIG_AsVal_int(obj2, &val3);
38918 if (!SWIG_IsOK(ecode3)) {
38919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38920 }
38921 arg3 = static_cast< int >(val3);
38922 {
38923 arg4 = wxString_in_helper(obj3);
38924 if (arg4 == NULL) SWIG_fail;
38925 temp4 = true;
38926 }
38927 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38928 if (!SWIG_IsOK(res5)) {
38929 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38930 }
38931 arg5 = reinterpret_cast< wxMenu * >(argp5);
38932 if (obj5) {
38933 {
38934 arg6 = wxString_in_helper(obj5);
38935 if (arg6 == NULL) SWIG_fail;
38936 temp6 = true;
38937 }
38938 }
38939 {
38940 PyThreadState* __tstate = wxPyBeginAllowThreads();
38941 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38942 wxPyEndAllowThreads(__tstate);
38943 if (PyErr_Occurred()) SWIG_fail;
38944 }
38945 {
38946 resultobj = wxPyMake_wxObject(result, (bool)0);
38947 }
38948 {
38949 if (temp4)
38950 delete arg4;
38951 }
38952 {
38953 if (temp6)
38954 delete arg6;
38955 }
38956 return resultobj;
38957 fail:
38958 {
38959 if (temp4)
38960 delete arg4;
38961 }
38962 {
38963 if (temp6)
38964 delete arg6;
38965 }
38966 return NULL;
38967 }
38968
38969
38970 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38971 PyObject *resultobj = 0;
38972 wxMenu *arg1 = (wxMenu *) 0 ;
38973 int arg2 ;
38974 wxString *arg3 = 0 ;
38975 wxString const &arg4_defvalue = wxPyEmptyString ;
38976 wxString *arg4 = (wxString *) &arg4_defvalue ;
38977 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38978 wxMenuItem *result = 0 ;
38979 void *argp1 = 0 ;
38980 int res1 = 0 ;
38981 int val2 ;
38982 int ecode2 = 0 ;
38983 bool temp3 = false ;
38984 bool temp4 = false ;
38985 int val5 ;
38986 int ecode5 = 0 ;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 PyObject * obj2 = 0 ;
38990 PyObject * obj3 = 0 ;
38991 PyObject * obj4 = 0 ;
38992 char * kwnames[] = {
38993 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38994 };
38995
38996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38998 if (!SWIG_IsOK(res1)) {
38999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39000 }
39001 arg1 = reinterpret_cast< wxMenu * >(argp1);
39002 ecode2 = SWIG_AsVal_int(obj1, &val2);
39003 if (!SWIG_IsOK(ecode2)) {
39004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39005 }
39006 arg2 = static_cast< int >(val2);
39007 {
39008 arg3 = wxString_in_helper(obj2);
39009 if (arg3 == NULL) SWIG_fail;
39010 temp3 = true;
39011 }
39012 if (obj3) {
39013 {
39014 arg4 = wxString_in_helper(obj3);
39015 if (arg4 == NULL) SWIG_fail;
39016 temp4 = true;
39017 }
39018 }
39019 if (obj4) {
39020 ecode5 = SWIG_AsVal_int(obj4, &val5);
39021 if (!SWIG_IsOK(ecode5)) {
39022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39023 }
39024 arg5 = static_cast< wxItemKind >(val5);
39025 }
39026 {
39027 PyThreadState* __tstate = wxPyBeginAllowThreads();
39028 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39029 wxPyEndAllowThreads(__tstate);
39030 if (PyErr_Occurred()) SWIG_fail;
39031 }
39032 {
39033 resultobj = wxPyMake_wxObject(result, (bool)0);
39034 }
39035 {
39036 if (temp3)
39037 delete arg3;
39038 }
39039 {
39040 if (temp4)
39041 delete arg4;
39042 }
39043 return resultobj;
39044 fail:
39045 {
39046 if (temp3)
39047 delete arg3;
39048 }
39049 {
39050 if (temp4)
39051 delete arg4;
39052 }
39053 return NULL;
39054 }
39055
39056
39057 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39058 PyObject *resultobj = 0;
39059 wxMenu *arg1 = (wxMenu *) 0 ;
39060 wxMenuItem *result = 0 ;
39061 void *argp1 = 0 ;
39062 int res1 = 0 ;
39063 PyObject *swig_obj[1] ;
39064
39065 if (!args) SWIG_fail;
39066 swig_obj[0] = args;
39067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39068 if (!SWIG_IsOK(res1)) {
39069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39070 }
39071 arg1 = reinterpret_cast< wxMenu * >(argp1);
39072 {
39073 PyThreadState* __tstate = wxPyBeginAllowThreads();
39074 result = (wxMenuItem *)(arg1)->PrependSeparator();
39075 wxPyEndAllowThreads(__tstate);
39076 if (PyErr_Occurred()) SWIG_fail;
39077 }
39078 {
39079 resultobj = wxPyMake_wxObject(result, (bool)0);
39080 }
39081 return resultobj;
39082 fail:
39083 return NULL;
39084 }
39085
39086
39087 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39088 PyObject *resultobj = 0;
39089 wxMenu *arg1 = (wxMenu *) 0 ;
39090 int arg2 ;
39091 wxString *arg3 = 0 ;
39092 wxString const &arg4_defvalue = wxPyEmptyString ;
39093 wxString *arg4 = (wxString *) &arg4_defvalue ;
39094 wxMenuItem *result = 0 ;
39095 void *argp1 = 0 ;
39096 int res1 = 0 ;
39097 int val2 ;
39098 int ecode2 = 0 ;
39099 bool temp3 = false ;
39100 bool temp4 = false ;
39101 PyObject * obj0 = 0 ;
39102 PyObject * obj1 = 0 ;
39103 PyObject * obj2 = 0 ;
39104 PyObject * obj3 = 0 ;
39105 char * kwnames[] = {
39106 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39107 };
39108
39109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39111 if (!SWIG_IsOK(res1)) {
39112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39113 }
39114 arg1 = reinterpret_cast< wxMenu * >(argp1);
39115 ecode2 = SWIG_AsVal_int(obj1, &val2);
39116 if (!SWIG_IsOK(ecode2)) {
39117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39118 }
39119 arg2 = static_cast< int >(val2);
39120 {
39121 arg3 = wxString_in_helper(obj2);
39122 if (arg3 == NULL) SWIG_fail;
39123 temp3 = true;
39124 }
39125 if (obj3) {
39126 {
39127 arg4 = wxString_in_helper(obj3);
39128 if (arg4 == NULL) SWIG_fail;
39129 temp4 = true;
39130 }
39131 }
39132 {
39133 PyThreadState* __tstate = wxPyBeginAllowThreads();
39134 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 {
39139 resultobj = wxPyMake_wxObject(result, (bool)0);
39140 }
39141 {
39142 if (temp3)
39143 delete arg3;
39144 }
39145 {
39146 if (temp4)
39147 delete arg4;
39148 }
39149 return resultobj;
39150 fail:
39151 {
39152 if (temp3)
39153 delete arg3;
39154 }
39155 {
39156 if (temp4)
39157 delete arg4;
39158 }
39159 return NULL;
39160 }
39161
39162
39163 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39164 PyObject *resultobj = 0;
39165 wxMenu *arg1 = (wxMenu *) 0 ;
39166 int arg2 ;
39167 wxString *arg3 = 0 ;
39168 wxString const &arg4_defvalue = wxPyEmptyString ;
39169 wxString *arg4 = (wxString *) &arg4_defvalue ;
39170 wxMenuItem *result = 0 ;
39171 void *argp1 = 0 ;
39172 int res1 = 0 ;
39173 int val2 ;
39174 int ecode2 = 0 ;
39175 bool temp3 = false ;
39176 bool temp4 = false ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 PyObject * obj2 = 0 ;
39180 PyObject * obj3 = 0 ;
39181 char * kwnames[] = {
39182 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39183 };
39184
39185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39187 if (!SWIG_IsOK(res1)) {
39188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39189 }
39190 arg1 = reinterpret_cast< wxMenu * >(argp1);
39191 ecode2 = SWIG_AsVal_int(obj1, &val2);
39192 if (!SWIG_IsOK(ecode2)) {
39193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39194 }
39195 arg2 = static_cast< int >(val2);
39196 {
39197 arg3 = wxString_in_helper(obj2);
39198 if (arg3 == NULL) SWIG_fail;
39199 temp3 = true;
39200 }
39201 if (obj3) {
39202 {
39203 arg4 = wxString_in_helper(obj3);
39204 if (arg4 == NULL) SWIG_fail;
39205 temp4 = true;
39206 }
39207 }
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 {
39215 resultobj = wxPyMake_wxObject(result, (bool)0);
39216 }
39217 {
39218 if (temp3)
39219 delete arg3;
39220 }
39221 {
39222 if (temp4)
39223 delete arg4;
39224 }
39225 return resultobj;
39226 fail:
39227 {
39228 if (temp3)
39229 delete arg3;
39230 }
39231 {
39232 if (temp4)
39233 delete arg4;
39234 }
39235 return NULL;
39236 }
39237
39238
39239 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39240 PyObject *resultobj = 0;
39241 wxMenu *arg1 = (wxMenu *) 0 ;
39242 int arg2 ;
39243 wxString *arg3 = 0 ;
39244 wxMenu *arg4 = (wxMenu *) 0 ;
39245 wxString const &arg5_defvalue = wxPyEmptyString ;
39246 wxString *arg5 = (wxString *) &arg5_defvalue ;
39247 wxMenuItem *result = 0 ;
39248 void *argp1 = 0 ;
39249 int res1 = 0 ;
39250 int val2 ;
39251 int ecode2 = 0 ;
39252 bool temp3 = false ;
39253 void *argp4 = 0 ;
39254 int res4 = 0 ;
39255 bool temp5 = false ;
39256 PyObject * obj0 = 0 ;
39257 PyObject * obj1 = 0 ;
39258 PyObject * obj2 = 0 ;
39259 PyObject * obj3 = 0 ;
39260 PyObject * obj4 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39269 }
39270 arg1 = reinterpret_cast< wxMenu * >(argp1);
39271 ecode2 = SWIG_AsVal_int(obj1, &val2);
39272 if (!SWIG_IsOK(ecode2)) {
39273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39274 }
39275 arg2 = static_cast< int >(val2);
39276 {
39277 arg3 = wxString_in_helper(obj2);
39278 if (arg3 == NULL) SWIG_fail;
39279 temp3 = true;
39280 }
39281 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39282 if (!SWIG_IsOK(res4)) {
39283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39284 }
39285 arg4 = reinterpret_cast< wxMenu * >(argp4);
39286 if (obj4) {
39287 {
39288 arg5 = wxString_in_helper(obj4);
39289 if (arg5 == NULL) SWIG_fail;
39290 temp5 = true;
39291 }
39292 }
39293 {
39294 PyThreadState* __tstate = wxPyBeginAllowThreads();
39295 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39296 wxPyEndAllowThreads(__tstate);
39297 if (PyErr_Occurred()) SWIG_fail;
39298 }
39299 {
39300 resultobj = wxPyMake_wxObject(result, (bool)0);
39301 }
39302 {
39303 if (temp3)
39304 delete arg3;
39305 }
39306 {
39307 if (temp5)
39308 delete arg5;
39309 }
39310 return resultobj;
39311 fail:
39312 {
39313 if (temp3)
39314 delete arg3;
39315 }
39316 {
39317 if (temp5)
39318 delete arg5;
39319 }
39320 return NULL;
39321 }
39322
39323
39324 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39325 PyObject *resultobj = 0;
39326 wxMenu *arg1 = (wxMenu *) 0 ;
39327 int arg2 ;
39328 wxMenuItem *result = 0 ;
39329 void *argp1 = 0 ;
39330 int res1 = 0 ;
39331 int val2 ;
39332 int ecode2 = 0 ;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 char * kwnames[] = {
39336 (char *) "self",(char *) "id", NULL
39337 };
39338
39339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39341 if (!SWIG_IsOK(res1)) {
39342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39343 }
39344 arg1 = reinterpret_cast< wxMenu * >(argp1);
39345 ecode2 = SWIG_AsVal_int(obj1, &val2);
39346 if (!SWIG_IsOK(ecode2)) {
39347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39348 }
39349 arg2 = static_cast< int >(val2);
39350 {
39351 PyThreadState* __tstate = wxPyBeginAllowThreads();
39352 result = (wxMenuItem *)(arg1)->Remove(arg2);
39353 wxPyEndAllowThreads(__tstate);
39354 if (PyErr_Occurred()) SWIG_fail;
39355 }
39356 {
39357 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39358 }
39359 return resultobj;
39360 fail:
39361 return NULL;
39362 }
39363
39364
39365 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39366 PyObject *resultobj = 0;
39367 wxMenu *arg1 = (wxMenu *) 0 ;
39368 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39369 wxMenuItem *result = 0 ;
39370 void *argp1 = 0 ;
39371 int res1 = 0 ;
39372 void *argp2 = 0 ;
39373 int res2 = 0 ;
39374 PyObject * obj0 = 0 ;
39375 PyObject * obj1 = 0 ;
39376 char * kwnames[] = {
39377 (char *) "self",(char *) "item", NULL
39378 };
39379
39380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39382 if (!SWIG_IsOK(res1)) {
39383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39384 }
39385 arg1 = reinterpret_cast< wxMenu * >(argp1);
39386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39387 if (!SWIG_IsOK(res2)) {
39388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39389 }
39390 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 result = (wxMenuItem *)(arg1)->Remove(arg2);
39394 wxPyEndAllowThreads(__tstate);
39395 if (PyErr_Occurred()) SWIG_fail;
39396 }
39397 {
39398 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39399 }
39400 return resultobj;
39401 fail:
39402 return NULL;
39403 }
39404
39405
39406 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39407 PyObject *resultobj = 0;
39408 wxMenu *arg1 = (wxMenu *) 0 ;
39409 int arg2 ;
39410 bool result;
39411 void *argp1 = 0 ;
39412 int res1 = 0 ;
39413 int val2 ;
39414 int ecode2 = 0 ;
39415 PyObject * obj0 = 0 ;
39416 PyObject * obj1 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "self",(char *) "id", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39423 if (!SWIG_IsOK(res1)) {
39424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39425 }
39426 arg1 = reinterpret_cast< wxMenu * >(argp1);
39427 ecode2 = SWIG_AsVal_int(obj1, &val2);
39428 if (!SWIG_IsOK(ecode2)) {
39429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39430 }
39431 arg2 = static_cast< int >(val2);
39432 {
39433 PyThreadState* __tstate = wxPyBeginAllowThreads();
39434 result = (bool)(arg1)->Delete(arg2);
39435 wxPyEndAllowThreads(__tstate);
39436 if (PyErr_Occurred()) SWIG_fail;
39437 }
39438 {
39439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39440 }
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39448 PyObject *resultobj = 0;
39449 wxMenu *arg1 = (wxMenu *) 0 ;
39450 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39451 bool result;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 void *argp2 = 0 ;
39455 int res2 = 0 ;
39456 PyObject * obj0 = 0 ;
39457 PyObject * obj1 = 0 ;
39458 char * kwnames[] = {
39459 (char *) "self",(char *) "item", NULL
39460 };
39461
39462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39466 }
39467 arg1 = reinterpret_cast< wxMenu * >(argp1);
39468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39469 if (!SWIG_IsOK(res2)) {
39470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39471 }
39472 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (bool)(arg1)->Delete(arg2);
39476 wxPyEndAllowThreads(__tstate);
39477 if (PyErr_Occurred()) SWIG_fail;
39478 }
39479 {
39480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39481 }
39482 return resultobj;
39483 fail:
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39489 PyObject *resultobj = 0;
39490 wxMenu *arg1 = (wxMenu *) 0 ;
39491 void *argp1 = 0 ;
39492 int res1 = 0 ;
39493 PyObject *swig_obj[1] ;
39494
39495 if (!args) SWIG_fail;
39496 swig_obj[0] = args;
39497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39500 }
39501 arg1 = reinterpret_cast< wxMenu * >(argp1);
39502 {
39503 PyThreadState* __tstate = wxPyBeginAllowThreads();
39504 wxMenu_Destroy(arg1);
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 resultobj = SWIG_Py_Void();
39509 return resultobj;
39510 fail:
39511 return NULL;
39512 }
39513
39514
39515 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39516 PyObject *resultobj = 0;
39517 wxMenu *arg1 = (wxMenu *) 0 ;
39518 int arg2 ;
39519 bool result;
39520 void *argp1 = 0 ;
39521 int res1 = 0 ;
39522 int val2 ;
39523 int ecode2 = 0 ;
39524 PyObject * obj0 = 0 ;
39525 PyObject * obj1 = 0 ;
39526 char * kwnames[] = {
39527 (char *) "self",(char *) "id", NULL
39528 };
39529
39530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39532 if (!SWIG_IsOK(res1)) {
39533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39534 }
39535 arg1 = reinterpret_cast< wxMenu * >(argp1);
39536 ecode2 = SWIG_AsVal_int(obj1, &val2);
39537 if (!SWIG_IsOK(ecode2)) {
39538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39539 }
39540 arg2 = static_cast< int >(val2);
39541 {
39542 PyThreadState* __tstate = wxPyBeginAllowThreads();
39543 result = (bool)(arg1)->Destroy(arg2);
39544 wxPyEndAllowThreads(__tstate);
39545 if (PyErr_Occurred()) SWIG_fail;
39546 }
39547 {
39548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39549 }
39550 return resultobj;
39551 fail:
39552 return NULL;
39553 }
39554
39555
39556 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39557 PyObject *resultobj = 0;
39558 wxMenu *arg1 = (wxMenu *) 0 ;
39559 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39560 bool result;
39561 void *argp1 = 0 ;
39562 int res1 = 0 ;
39563 void *argp2 = 0 ;
39564 int res2 = 0 ;
39565 PyObject * obj0 = 0 ;
39566 PyObject * obj1 = 0 ;
39567 char * kwnames[] = {
39568 (char *) "self",(char *) "item", NULL
39569 };
39570
39571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39573 if (!SWIG_IsOK(res1)) {
39574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39575 }
39576 arg1 = reinterpret_cast< wxMenu * >(argp1);
39577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39578 if (!SWIG_IsOK(res2)) {
39579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39580 }
39581 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (bool)(arg1)->Destroy(arg2);
39585 wxPyEndAllowThreads(__tstate);
39586 if (PyErr_Occurred()) SWIG_fail;
39587 }
39588 {
39589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39590 }
39591 return resultobj;
39592 fail:
39593 return NULL;
39594 }
39595
39596
39597 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39598 PyObject *resultobj = 0;
39599 wxMenu *arg1 = (wxMenu *) 0 ;
39600 size_t result;
39601 void *argp1 = 0 ;
39602 int res1 = 0 ;
39603 PyObject *swig_obj[1] ;
39604
39605 if (!args) SWIG_fail;
39606 swig_obj[0] = args;
39607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39608 if (!SWIG_IsOK(res1)) {
39609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39610 }
39611 arg1 = reinterpret_cast< wxMenu * >(argp1);
39612 {
39613 PyThreadState* __tstate = wxPyBeginAllowThreads();
39614 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39615 wxPyEndAllowThreads(__tstate);
39616 if (PyErr_Occurred()) SWIG_fail;
39617 }
39618 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39619 return resultobj;
39620 fail:
39621 return NULL;
39622 }
39623
39624
39625 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39626 PyObject *resultobj = 0;
39627 wxMenu *arg1 = (wxMenu *) 0 ;
39628 PyObject *result = 0 ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 PyObject *swig_obj[1] ;
39632
39633 if (!args) SWIG_fail;
39634 swig_obj[0] = args;
39635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39636 if (!SWIG_IsOK(res1)) {
39637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39638 }
39639 arg1 = reinterpret_cast< wxMenu * >(argp1);
39640 {
39641 PyThreadState* __tstate = wxPyBeginAllowThreads();
39642 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39643 wxPyEndAllowThreads(__tstate);
39644 if (PyErr_Occurred()) SWIG_fail;
39645 }
39646 resultobj = result;
39647 return resultobj;
39648 fail:
39649 return NULL;
39650 }
39651
39652
39653 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39654 PyObject *resultobj = 0;
39655 wxMenu *arg1 = (wxMenu *) 0 ;
39656 wxString *arg2 = 0 ;
39657 int result;
39658 void *argp1 = 0 ;
39659 int res1 = 0 ;
39660 bool temp2 = false ;
39661 PyObject * obj0 = 0 ;
39662 PyObject * obj1 = 0 ;
39663 char * kwnames[] = {
39664 (char *) "self",(char *) "item", NULL
39665 };
39666
39667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39669 if (!SWIG_IsOK(res1)) {
39670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39671 }
39672 arg1 = reinterpret_cast< wxMenu * >(argp1);
39673 {
39674 arg2 = wxString_in_helper(obj1);
39675 if (arg2 == NULL) SWIG_fail;
39676 temp2 = true;
39677 }
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 resultobj = SWIG_From_int(static_cast< int >(result));
39685 {
39686 if (temp2)
39687 delete arg2;
39688 }
39689 return resultobj;
39690 fail:
39691 {
39692 if (temp2)
39693 delete arg2;
39694 }
39695 return NULL;
39696 }
39697
39698
39699 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39700 PyObject *resultobj = 0;
39701 wxMenu *arg1 = (wxMenu *) 0 ;
39702 int arg2 ;
39703 wxMenuItem *result = 0 ;
39704 void *argp1 = 0 ;
39705 int res1 = 0 ;
39706 int val2 ;
39707 int ecode2 = 0 ;
39708 PyObject * obj0 = 0 ;
39709 PyObject * obj1 = 0 ;
39710 char * kwnames[] = {
39711 (char *) "self",(char *) "id", NULL
39712 };
39713
39714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39716 if (!SWIG_IsOK(res1)) {
39717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39718 }
39719 arg1 = reinterpret_cast< wxMenu * >(argp1);
39720 ecode2 = SWIG_AsVal_int(obj1, &val2);
39721 if (!SWIG_IsOK(ecode2)) {
39722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39723 }
39724 arg2 = static_cast< int >(val2);
39725 {
39726 PyThreadState* __tstate = wxPyBeginAllowThreads();
39727 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39728 wxPyEndAllowThreads(__tstate);
39729 if (PyErr_Occurred()) SWIG_fail;
39730 }
39731 {
39732 resultobj = wxPyMake_wxObject(result, (bool)0);
39733 }
39734 return resultobj;
39735 fail:
39736 return NULL;
39737 }
39738
39739
39740 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39741 PyObject *resultobj = 0;
39742 wxMenu *arg1 = (wxMenu *) 0 ;
39743 size_t arg2 ;
39744 wxMenuItem *result = 0 ;
39745 void *argp1 = 0 ;
39746 int res1 = 0 ;
39747 size_t val2 ;
39748 int ecode2 = 0 ;
39749 PyObject * obj0 = 0 ;
39750 PyObject * obj1 = 0 ;
39751 char * kwnames[] = {
39752 (char *) "self",(char *) "position", NULL
39753 };
39754
39755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39757 if (!SWIG_IsOK(res1)) {
39758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39759 }
39760 arg1 = reinterpret_cast< wxMenu * >(argp1);
39761 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39762 if (!SWIG_IsOK(ecode2)) {
39763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39764 }
39765 arg2 = static_cast< size_t >(val2);
39766 {
39767 PyThreadState* __tstate = wxPyBeginAllowThreads();
39768 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39769 wxPyEndAllowThreads(__tstate);
39770 if (PyErr_Occurred()) SWIG_fail;
39771 }
39772 {
39773 resultobj = wxPyMake_wxObject(result, (bool)0);
39774 }
39775 return resultobj;
39776 fail:
39777 return NULL;
39778 }
39779
39780
39781 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39782 PyObject *resultobj = 0;
39783 wxMenu *arg1 = (wxMenu *) 0 ;
39784 int arg2 ;
39785 bool arg3 ;
39786 void *argp1 = 0 ;
39787 int res1 = 0 ;
39788 int val2 ;
39789 int ecode2 = 0 ;
39790 bool val3 ;
39791 int ecode3 = 0 ;
39792 PyObject * obj0 = 0 ;
39793 PyObject * obj1 = 0 ;
39794 PyObject * obj2 = 0 ;
39795 char * kwnames[] = {
39796 (char *) "self",(char *) "id",(char *) "enable", NULL
39797 };
39798
39799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39801 if (!SWIG_IsOK(res1)) {
39802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39803 }
39804 arg1 = reinterpret_cast< wxMenu * >(argp1);
39805 ecode2 = SWIG_AsVal_int(obj1, &val2);
39806 if (!SWIG_IsOK(ecode2)) {
39807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39808 }
39809 arg2 = static_cast< int >(val2);
39810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39811 if (!SWIG_IsOK(ecode3)) {
39812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39813 }
39814 arg3 = static_cast< bool >(val3);
39815 {
39816 PyThreadState* __tstate = wxPyBeginAllowThreads();
39817 (arg1)->Enable(arg2,arg3);
39818 wxPyEndAllowThreads(__tstate);
39819 if (PyErr_Occurred()) SWIG_fail;
39820 }
39821 resultobj = SWIG_Py_Void();
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj = 0;
39830 wxMenu *arg1 = (wxMenu *) 0 ;
39831 int arg2 ;
39832 bool result;
39833 void *argp1 = 0 ;
39834 int res1 = 0 ;
39835 int val2 ;
39836 int ecode2 = 0 ;
39837 PyObject * obj0 = 0 ;
39838 PyObject * obj1 = 0 ;
39839 char * kwnames[] = {
39840 (char *) "self",(char *) "id", NULL
39841 };
39842
39843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39845 if (!SWIG_IsOK(res1)) {
39846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39847 }
39848 arg1 = reinterpret_cast< wxMenu * >(argp1);
39849 ecode2 = SWIG_AsVal_int(obj1, &val2);
39850 if (!SWIG_IsOK(ecode2)) {
39851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39852 }
39853 arg2 = static_cast< int >(val2);
39854 {
39855 PyThreadState* __tstate = wxPyBeginAllowThreads();
39856 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39857 wxPyEndAllowThreads(__tstate);
39858 if (PyErr_Occurred()) SWIG_fail;
39859 }
39860 {
39861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39862 }
39863 return resultobj;
39864 fail:
39865 return NULL;
39866 }
39867
39868
39869 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39870 PyObject *resultobj = 0;
39871 wxMenu *arg1 = (wxMenu *) 0 ;
39872 int arg2 ;
39873 bool arg3 ;
39874 void *argp1 = 0 ;
39875 int res1 = 0 ;
39876 int val2 ;
39877 int ecode2 = 0 ;
39878 bool val3 ;
39879 int ecode3 = 0 ;
39880 PyObject * obj0 = 0 ;
39881 PyObject * obj1 = 0 ;
39882 PyObject * obj2 = 0 ;
39883 char * kwnames[] = {
39884 (char *) "self",(char *) "id",(char *) "check", NULL
39885 };
39886
39887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39889 if (!SWIG_IsOK(res1)) {
39890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39891 }
39892 arg1 = reinterpret_cast< wxMenu * >(argp1);
39893 ecode2 = SWIG_AsVal_int(obj1, &val2);
39894 if (!SWIG_IsOK(ecode2)) {
39895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39896 }
39897 arg2 = static_cast< int >(val2);
39898 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39899 if (!SWIG_IsOK(ecode3)) {
39900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39901 }
39902 arg3 = static_cast< bool >(val3);
39903 {
39904 PyThreadState* __tstate = wxPyBeginAllowThreads();
39905 (arg1)->Check(arg2,arg3);
39906 wxPyEndAllowThreads(__tstate);
39907 if (PyErr_Occurred()) SWIG_fail;
39908 }
39909 resultobj = SWIG_Py_Void();
39910 return resultobj;
39911 fail:
39912 return NULL;
39913 }
39914
39915
39916 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39917 PyObject *resultobj = 0;
39918 wxMenu *arg1 = (wxMenu *) 0 ;
39919 int arg2 ;
39920 bool result;
39921 void *argp1 = 0 ;
39922 int res1 = 0 ;
39923 int val2 ;
39924 int ecode2 = 0 ;
39925 PyObject * obj0 = 0 ;
39926 PyObject * obj1 = 0 ;
39927 char * kwnames[] = {
39928 (char *) "self",(char *) "id", NULL
39929 };
39930
39931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39933 if (!SWIG_IsOK(res1)) {
39934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39935 }
39936 arg1 = reinterpret_cast< wxMenu * >(argp1);
39937 ecode2 = SWIG_AsVal_int(obj1, &val2);
39938 if (!SWIG_IsOK(ecode2)) {
39939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39940 }
39941 arg2 = static_cast< int >(val2);
39942 {
39943 PyThreadState* __tstate = wxPyBeginAllowThreads();
39944 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39945 wxPyEndAllowThreads(__tstate);
39946 if (PyErr_Occurred()) SWIG_fail;
39947 }
39948 {
39949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39950 }
39951 return resultobj;
39952 fail:
39953 return NULL;
39954 }
39955
39956
39957 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39958 PyObject *resultobj = 0;
39959 wxMenu *arg1 = (wxMenu *) 0 ;
39960 int arg2 ;
39961 wxString *arg3 = 0 ;
39962 void *argp1 = 0 ;
39963 int res1 = 0 ;
39964 int val2 ;
39965 int ecode2 = 0 ;
39966 bool temp3 = false ;
39967 PyObject * obj0 = 0 ;
39968 PyObject * obj1 = 0 ;
39969 PyObject * obj2 = 0 ;
39970 char * kwnames[] = {
39971 (char *) "self",(char *) "id",(char *) "label", NULL
39972 };
39973
39974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39976 if (!SWIG_IsOK(res1)) {
39977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39978 }
39979 arg1 = reinterpret_cast< wxMenu * >(argp1);
39980 ecode2 = SWIG_AsVal_int(obj1, &val2);
39981 if (!SWIG_IsOK(ecode2)) {
39982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39983 }
39984 arg2 = static_cast< int >(val2);
39985 {
39986 arg3 = wxString_in_helper(obj2);
39987 if (arg3 == NULL) SWIG_fail;
39988 temp3 = true;
39989 }
39990 {
39991 PyThreadState* __tstate = wxPyBeginAllowThreads();
39992 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 resultobj = SWIG_Py_Void();
39997 {
39998 if (temp3)
39999 delete arg3;
40000 }
40001 return resultobj;
40002 fail:
40003 {
40004 if (temp3)
40005 delete arg3;
40006 }
40007 return NULL;
40008 }
40009
40010
40011 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40012 PyObject *resultobj = 0;
40013 wxMenu *arg1 = (wxMenu *) 0 ;
40014 int arg2 ;
40015 wxString result;
40016 void *argp1 = 0 ;
40017 int res1 = 0 ;
40018 int val2 ;
40019 int ecode2 = 0 ;
40020 PyObject * obj0 = 0 ;
40021 PyObject * obj1 = 0 ;
40022 char * kwnames[] = {
40023 (char *) "self",(char *) "id", NULL
40024 };
40025
40026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40028 if (!SWIG_IsOK(res1)) {
40029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40030 }
40031 arg1 = reinterpret_cast< wxMenu * >(argp1);
40032 ecode2 = SWIG_AsVal_int(obj1, &val2);
40033 if (!SWIG_IsOK(ecode2)) {
40034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40035 }
40036 arg2 = static_cast< int >(val2);
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 {
40044 #if wxUSE_UNICODE
40045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40046 #else
40047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40048 #endif
40049 }
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj = 0;
40058 wxMenu *arg1 = (wxMenu *) 0 ;
40059 int arg2 ;
40060 wxString *arg3 = 0 ;
40061 void *argp1 = 0 ;
40062 int res1 = 0 ;
40063 int val2 ;
40064 int ecode2 = 0 ;
40065 bool temp3 = false ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 PyObject * obj2 = 0 ;
40069 char * kwnames[] = {
40070 (char *) "self",(char *) "id",(char *) "helpString", NULL
40071 };
40072
40073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40075 if (!SWIG_IsOK(res1)) {
40076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40077 }
40078 arg1 = reinterpret_cast< wxMenu * >(argp1);
40079 ecode2 = SWIG_AsVal_int(obj1, &val2);
40080 if (!SWIG_IsOK(ecode2)) {
40081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40082 }
40083 arg2 = static_cast< int >(val2);
40084 {
40085 arg3 = wxString_in_helper(obj2);
40086 if (arg3 == NULL) SWIG_fail;
40087 temp3 = true;
40088 }
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40092 wxPyEndAllowThreads(__tstate);
40093 if (PyErr_Occurred()) SWIG_fail;
40094 }
40095 resultobj = SWIG_Py_Void();
40096 {
40097 if (temp3)
40098 delete arg3;
40099 }
40100 return resultobj;
40101 fail:
40102 {
40103 if (temp3)
40104 delete arg3;
40105 }
40106 return NULL;
40107 }
40108
40109
40110 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40111 PyObject *resultobj = 0;
40112 wxMenu *arg1 = (wxMenu *) 0 ;
40113 int arg2 ;
40114 wxString result;
40115 void *argp1 = 0 ;
40116 int res1 = 0 ;
40117 int val2 ;
40118 int ecode2 = 0 ;
40119 PyObject * obj0 = 0 ;
40120 PyObject * obj1 = 0 ;
40121 char * kwnames[] = {
40122 (char *) "self",(char *) "id", NULL
40123 };
40124
40125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40127 if (!SWIG_IsOK(res1)) {
40128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40129 }
40130 arg1 = reinterpret_cast< wxMenu * >(argp1);
40131 ecode2 = SWIG_AsVal_int(obj1, &val2);
40132 if (!SWIG_IsOK(ecode2)) {
40133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40134 }
40135 arg2 = static_cast< int >(val2);
40136 {
40137 PyThreadState* __tstate = wxPyBeginAllowThreads();
40138 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 #if wxUSE_UNICODE
40144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40145 #else
40146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40147 #endif
40148 }
40149 return resultobj;
40150 fail:
40151 return NULL;
40152 }
40153
40154
40155 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40156 PyObject *resultobj = 0;
40157 wxMenu *arg1 = (wxMenu *) 0 ;
40158 wxString *arg2 = 0 ;
40159 void *argp1 = 0 ;
40160 int res1 = 0 ;
40161 bool temp2 = false ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "title", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40172 }
40173 arg1 = reinterpret_cast< wxMenu * >(argp1);
40174 {
40175 arg2 = wxString_in_helper(obj1);
40176 if (arg2 == NULL) SWIG_fail;
40177 temp2 = true;
40178 }
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 (arg1)->SetTitle((wxString const &)*arg2);
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 resultobj = SWIG_Py_Void();
40186 {
40187 if (temp2)
40188 delete arg2;
40189 }
40190 return resultobj;
40191 fail:
40192 {
40193 if (temp2)
40194 delete arg2;
40195 }
40196 return NULL;
40197 }
40198
40199
40200 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40201 PyObject *resultobj = 0;
40202 wxMenu *arg1 = (wxMenu *) 0 ;
40203 wxString result;
40204 void *argp1 = 0 ;
40205 int res1 = 0 ;
40206 PyObject *swig_obj[1] ;
40207
40208 if (!args) SWIG_fail;
40209 swig_obj[0] = args;
40210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40211 if (!SWIG_IsOK(res1)) {
40212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40213 }
40214 arg1 = reinterpret_cast< wxMenu * >(argp1);
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = ((wxMenu const *)arg1)->GetTitle();
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 {
40222 #if wxUSE_UNICODE
40223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40224 #else
40225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40226 #endif
40227 }
40228 return resultobj;
40229 fail:
40230 return NULL;
40231 }
40232
40233
40234 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40235 PyObject *resultobj = 0;
40236 wxMenu *arg1 = (wxMenu *) 0 ;
40237 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40238 void *argp1 = 0 ;
40239 int res1 = 0 ;
40240 void *argp2 = 0 ;
40241 int res2 = 0 ;
40242 PyObject * obj0 = 0 ;
40243 PyObject * obj1 = 0 ;
40244 char * kwnames[] = {
40245 (char *) "self",(char *) "handler", NULL
40246 };
40247
40248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40250 if (!SWIG_IsOK(res1)) {
40251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40252 }
40253 arg1 = reinterpret_cast< wxMenu * >(argp1);
40254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40255 if (!SWIG_IsOK(res2)) {
40256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40257 }
40258 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 (arg1)->SetEventHandler(arg2);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 resultobj = SWIG_Py_Void();
40266 return resultobj;
40267 fail:
40268 return NULL;
40269 }
40270
40271
40272 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40273 PyObject *resultobj = 0;
40274 wxMenu *arg1 = (wxMenu *) 0 ;
40275 wxEvtHandler *result = 0 ;
40276 void *argp1 = 0 ;
40277 int res1 = 0 ;
40278 PyObject *swig_obj[1] ;
40279
40280 if (!args) SWIG_fail;
40281 swig_obj[0] = args;
40282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40283 if (!SWIG_IsOK(res1)) {
40284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40285 }
40286 arg1 = reinterpret_cast< wxMenu * >(argp1);
40287 {
40288 PyThreadState* __tstate = wxPyBeginAllowThreads();
40289 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40290 wxPyEndAllowThreads(__tstate);
40291 if (PyErr_Occurred()) SWIG_fail;
40292 }
40293 {
40294 resultobj = wxPyMake_wxObject(result, 0);
40295 }
40296 return resultobj;
40297 fail:
40298 return NULL;
40299 }
40300
40301
40302 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40303 PyObject *resultobj = 0;
40304 wxMenu *arg1 = (wxMenu *) 0 ;
40305 wxWindow *arg2 = (wxWindow *) 0 ;
40306 void *argp1 = 0 ;
40307 int res1 = 0 ;
40308 void *argp2 = 0 ;
40309 int res2 = 0 ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 char * kwnames[] = {
40313 (char *) "self",(char *) "win", NULL
40314 };
40315
40316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40318 if (!SWIG_IsOK(res1)) {
40319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40320 }
40321 arg1 = reinterpret_cast< wxMenu * >(argp1);
40322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40323 if (!SWIG_IsOK(res2)) {
40324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40325 }
40326 arg2 = reinterpret_cast< wxWindow * >(argp2);
40327 {
40328 PyThreadState* __tstate = wxPyBeginAllowThreads();
40329 (arg1)->SetInvokingWindow(arg2);
40330 wxPyEndAllowThreads(__tstate);
40331 if (PyErr_Occurred()) SWIG_fail;
40332 }
40333 resultobj = SWIG_Py_Void();
40334 return resultobj;
40335 fail:
40336 return NULL;
40337 }
40338
40339
40340 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40341 PyObject *resultobj = 0;
40342 wxMenu *arg1 = (wxMenu *) 0 ;
40343 wxWindow *result = 0 ;
40344 void *argp1 = 0 ;
40345 int res1 = 0 ;
40346 PyObject *swig_obj[1] ;
40347
40348 if (!args) SWIG_fail;
40349 swig_obj[0] = args;
40350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40351 if (!SWIG_IsOK(res1)) {
40352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40353 }
40354 arg1 = reinterpret_cast< wxMenu * >(argp1);
40355 {
40356 PyThreadState* __tstate = wxPyBeginAllowThreads();
40357 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 {
40362 resultobj = wxPyMake_wxObject(result, 0);
40363 }
40364 return resultobj;
40365 fail:
40366 return NULL;
40367 }
40368
40369
40370 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40371 PyObject *resultobj = 0;
40372 wxMenu *arg1 = (wxMenu *) 0 ;
40373 long result;
40374 void *argp1 = 0 ;
40375 int res1 = 0 ;
40376 PyObject *swig_obj[1] ;
40377
40378 if (!args) SWIG_fail;
40379 swig_obj[0] = args;
40380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 {
40386 PyThreadState* __tstate = wxPyBeginAllowThreads();
40387 result = (long)((wxMenu const *)arg1)->GetStyle();
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 resultobj = SWIG_From_long(static_cast< long >(result));
40392 return resultobj;
40393 fail:
40394 return NULL;
40395 }
40396
40397
40398 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40399 PyObject *resultobj = 0;
40400 wxMenu *arg1 = (wxMenu *) 0 ;
40401 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40402 void *argp1 = 0 ;
40403 int res1 = 0 ;
40404 void *argp2 = 0 ;
40405 int res2 = 0 ;
40406 PyObject * obj0 = 0 ;
40407 PyObject * obj1 = 0 ;
40408 char * kwnames[] = {
40409 (char *) "self",(char *) "source", NULL
40410 };
40411
40412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40414 if (!SWIG_IsOK(res1)) {
40415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40416 }
40417 arg1 = reinterpret_cast< wxMenu * >(argp1);
40418 if (obj1) {
40419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40420 if (!SWIG_IsOK(res2)) {
40421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40422 }
40423 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40424 }
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 (arg1)->UpdateUI(arg2);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 resultobj = SWIG_Py_Void();
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40439 PyObject *resultobj = 0;
40440 wxMenu *arg1 = (wxMenu *) 0 ;
40441 wxMenuBar *result = 0 ;
40442 void *argp1 = 0 ;
40443 int res1 = 0 ;
40444 PyObject *swig_obj[1] ;
40445
40446 if (!args) SWIG_fail;
40447 swig_obj[0] = args;
40448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40449 if (!SWIG_IsOK(res1)) {
40450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40451 }
40452 arg1 = reinterpret_cast< wxMenu * >(argp1);
40453 {
40454 PyThreadState* __tstate = wxPyBeginAllowThreads();
40455 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 {
40460 resultobj = wxPyMake_wxObject(result, (bool)0);
40461 }
40462 return resultobj;
40463 fail:
40464 return NULL;
40465 }
40466
40467
40468 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40469 PyObject *resultobj = 0;
40470 wxMenu *arg1 = (wxMenu *) 0 ;
40471 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40472 void *argp1 = 0 ;
40473 int res1 = 0 ;
40474 void *argp2 = 0 ;
40475 int res2 = 0 ;
40476 PyObject * obj0 = 0 ;
40477 PyObject * obj1 = 0 ;
40478 char * kwnames[] = {
40479 (char *) "self",(char *) "menubar", NULL
40480 };
40481
40482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40484 if (!SWIG_IsOK(res1)) {
40485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40486 }
40487 arg1 = reinterpret_cast< wxMenu * >(argp1);
40488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40489 if (!SWIG_IsOK(res2)) {
40490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40491 }
40492 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40493 {
40494 PyThreadState* __tstate = wxPyBeginAllowThreads();
40495 (arg1)->Attach(arg2);
40496 wxPyEndAllowThreads(__tstate);
40497 if (PyErr_Occurred()) SWIG_fail;
40498 }
40499 resultobj = SWIG_Py_Void();
40500 return resultobj;
40501 fail:
40502 return NULL;
40503 }
40504
40505
40506 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40507 PyObject *resultobj = 0;
40508 wxMenu *arg1 = (wxMenu *) 0 ;
40509 void *argp1 = 0 ;
40510 int res1 = 0 ;
40511 PyObject *swig_obj[1] ;
40512
40513 if (!args) SWIG_fail;
40514 swig_obj[0] = args;
40515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40516 if (!SWIG_IsOK(res1)) {
40517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40518 }
40519 arg1 = reinterpret_cast< wxMenu * >(argp1);
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 (arg1)->Detach();
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 resultobj = SWIG_Py_Void();
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 bool result;
40537 void *argp1 = 0 ;
40538 int res1 = 0 ;
40539 PyObject *swig_obj[1] ;
40540
40541 if (!args) SWIG_fail;
40542 swig_obj[0] = args;
40543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40546 }
40547 arg1 = reinterpret_cast< wxMenu * >(argp1);
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 result = (bool)((wxMenu const *)arg1)->IsAttached();
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 {
40555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40556 }
40557 return resultobj;
40558 fail:
40559 return NULL;
40560 }
40561
40562
40563 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40564 PyObject *resultobj = 0;
40565 wxMenu *arg1 = (wxMenu *) 0 ;
40566 wxMenu *arg2 = (wxMenu *) 0 ;
40567 void *argp1 = 0 ;
40568 int res1 = 0 ;
40569 void *argp2 = 0 ;
40570 int res2 = 0 ;
40571 PyObject * obj0 = 0 ;
40572 PyObject * obj1 = 0 ;
40573 char * kwnames[] = {
40574 (char *) "self",(char *) "parent", NULL
40575 };
40576
40577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40579 if (!SWIG_IsOK(res1)) {
40580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40581 }
40582 arg1 = reinterpret_cast< wxMenu * >(argp1);
40583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40584 if (!SWIG_IsOK(res2)) {
40585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40586 }
40587 arg2 = reinterpret_cast< wxMenu * >(argp2);
40588 {
40589 PyThreadState* __tstate = wxPyBeginAllowThreads();
40590 (arg1)->SetParent(arg2);
40591 wxPyEndAllowThreads(__tstate);
40592 if (PyErr_Occurred()) SWIG_fail;
40593 }
40594 resultobj = SWIG_Py_Void();
40595 return resultobj;
40596 fail:
40597 return NULL;
40598 }
40599
40600
40601 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40602 PyObject *resultobj = 0;
40603 wxMenu *arg1 = (wxMenu *) 0 ;
40604 wxMenu *result = 0 ;
40605 void *argp1 = 0 ;
40606 int res1 = 0 ;
40607 PyObject *swig_obj[1] ;
40608
40609 if (!args) SWIG_fail;
40610 swig_obj[0] = args;
40611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40612 if (!SWIG_IsOK(res1)) {
40613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40614 }
40615 arg1 = reinterpret_cast< wxMenu * >(argp1);
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 {
40623 resultobj = wxPyMake_wxObject(result, 0);
40624 }
40625 return resultobj;
40626 fail:
40627 return NULL;
40628 }
40629
40630
40631 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40632 PyObject *obj;
40633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40634 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40635 return SWIG_Py_Void();
40636 }
40637
40638 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40639 return SWIG_Python_InitShadowInstance(args);
40640 }
40641
40642 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj = 0;
40644 long arg1 = (long) 0 ;
40645 wxMenuBar *result = 0 ;
40646 long val1 ;
40647 int ecode1 = 0 ;
40648 PyObject * obj0 = 0 ;
40649 char * kwnames[] = {
40650 (char *) "style", NULL
40651 };
40652
40653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40654 if (obj0) {
40655 ecode1 = SWIG_AsVal_long(obj0, &val1);
40656 if (!SWIG_IsOK(ecode1)) {
40657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40658 }
40659 arg1 = static_cast< long >(val1);
40660 }
40661 {
40662 if (!wxPyCheckForApp()) SWIG_fail;
40663 PyThreadState* __tstate = wxPyBeginAllowThreads();
40664 result = (wxMenuBar *)new wxMenuBar(arg1);
40665 wxPyEndAllowThreads(__tstate);
40666 if (PyErr_Occurred()) SWIG_fail;
40667 }
40668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40669 return resultobj;
40670 fail:
40671 return NULL;
40672 }
40673
40674
40675 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40676 PyObject *resultobj = 0;
40677 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40678 wxMenu *arg2 = (wxMenu *) 0 ;
40679 wxString *arg3 = 0 ;
40680 bool result;
40681 void *argp1 = 0 ;
40682 int res1 = 0 ;
40683 void *argp2 = 0 ;
40684 int res2 = 0 ;
40685 bool temp3 = false ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 PyObject * obj2 = 0 ;
40689 char * kwnames[] = {
40690 (char *) "self",(char *) "menu",(char *) "title", NULL
40691 };
40692
40693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40695 if (!SWIG_IsOK(res1)) {
40696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40697 }
40698 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40700 if (!SWIG_IsOK(res2)) {
40701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40702 }
40703 arg2 = reinterpret_cast< wxMenu * >(argp2);
40704 {
40705 arg3 = wxString_in_helper(obj2);
40706 if (arg3 == NULL) SWIG_fail;
40707 temp3 = true;
40708 }
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40712 wxPyEndAllowThreads(__tstate);
40713 if (PyErr_Occurred()) SWIG_fail;
40714 }
40715 {
40716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40717 }
40718 {
40719 if (temp3)
40720 delete arg3;
40721 }
40722 return resultobj;
40723 fail:
40724 {
40725 if (temp3)
40726 delete arg3;
40727 }
40728 return NULL;
40729 }
40730
40731
40732 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj = 0;
40734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40735 size_t arg2 ;
40736 wxMenu *arg3 = (wxMenu *) 0 ;
40737 wxString *arg4 = 0 ;
40738 bool result;
40739 void *argp1 = 0 ;
40740 int res1 = 0 ;
40741 size_t val2 ;
40742 int ecode2 = 0 ;
40743 void *argp3 = 0 ;
40744 int res3 = 0 ;
40745 bool temp4 = false ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 PyObject * obj2 = 0 ;
40749 PyObject * obj3 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40756 if (!SWIG_IsOK(res1)) {
40757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40758 }
40759 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40761 if (!SWIG_IsOK(ecode2)) {
40762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40763 }
40764 arg2 = static_cast< size_t >(val2);
40765 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40766 if (!SWIG_IsOK(res3)) {
40767 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40768 }
40769 arg3 = reinterpret_cast< wxMenu * >(argp3);
40770 {
40771 arg4 = wxString_in_helper(obj3);
40772 if (arg4 == NULL) SWIG_fail;
40773 temp4 = true;
40774 }
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40778 wxPyEndAllowThreads(__tstate);
40779 if (PyErr_Occurred()) SWIG_fail;
40780 }
40781 {
40782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40783 }
40784 {
40785 if (temp4)
40786 delete arg4;
40787 }
40788 return resultobj;
40789 fail:
40790 {
40791 if (temp4)
40792 delete arg4;
40793 }
40794 return NULL;
40795 }
40796
40797
40798 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40799 PyObject *resultobj = 0;
40800 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40801 size_t result;
40802 void *argp1 = 0 ;
40803 int res1 = 0 ;
40804 PyObject *swig_obj[1] ;
40805
40806 if (!args) SWIG_fail;
40807 swig_obj[0] = args;
40808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40809 if (!SWIG_IsOK(res1)) {
40810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40811 }
40812 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40813 {
40814 PyThreadState* __tstate = wxPyBeginAllowThreads();
40815 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj = 0;
40828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40829 size_t arg2 ;
40830 wxMenu *result = 0 ;
40831 void *argp1 = 0 ;
40832 int res1 = 0 ;
40833 size_t val2 ;
40834 int ecode2 = 0 ;
40835 PyObject * obj0 = 0 ;
40836 PyObject * obj1 = 0 ;
40837 char * kwnames[] = {
40838 (char *) "self",(char *) "pos", NULL
40839 };
40840
40841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40847 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40848 if (!SWIG_IsOK(ecode2)) {
40849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40850 }
40851 arg2 = static_cast< size_t >(val2);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = wxPyMake_wxObject(result, 0);
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj = 0;
40869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40870 size_t arg2 ;
40871 wxMenu *arg3 = (wxMenu *) 0 ;
40872 wxString *arg4 = 0 ;
40873 wxMenu *result = 0 ;
40874 void *argp1 = 0 ;
40875 int res1 = 0 ;
40876 size_t val2 ;
40877 int ecode2 = 0 ;
40878 void *argp3 = 0 ;
40879 int res3 = 0 ;
40880 bool temp4 = false ;
40881 PyObject * obj0 = 0 ;
40882 PyObject * obj1 = 0 ;
40883 PyObject * obj2 = 0 ;
40884 PyObject * obj3 = 0 ;
40885 char * kwnames[] = {
40886 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40887 };
40888
40889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40891 if (!SWIG_IsOK(res1)) {
40892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40893 }
40894 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40895 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40896 if (!SWIG_IsOK(ecode2)) {
40897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40898 }
40899 arg2 = static_cast< size_t >(val2);
40900 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40901 if (!SWIG_IsOK(res3)) {
40902 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40903 }
40904 arg3 = reinterpret_cast< wxMenu * >(argp3);
40905 {
40906 arg4 = wxString_in_helper(obj3);
40907 if (arg4 == NULL) SWIG_fail;
40908 temp4 = true;
40909 }
40910 {
40911 PyThreadState* __tstate = wxPyBeginAllowThreads();
40912 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40913 wxPyEndAllowThreads(__tstate);
40914 if (PyErr_Occurred()) SWIG_fail;
40915 }
40916 {
40917 resultobj = wxPyMake_wxObject(result, 0);
40918 }
40919 {
40920 if (temp4)
40921 delete arg4;
40922 }
40923 return resultobj;
40924 fail:
40925 {
40926 if (temp4)
40927 delete arg4;
40928 }
40929 return NULL;
40930 }
40931
40932
40933 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40934 PyObject *resultobj = 0;
40935 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40936 size_t arg2 ;
40937 wxMenu *result = 0 ;
40938 void *argp1 = 0 ;
40939 int res1 = 0 ;
40940 size_t val2 ;
40941 int ecode2 = 0 ;
40942 PyObject * obj0 = 0 ;
40943 PyObject * obj1 = 0 ;
40944 char * kwnames[] = {
40945 (char *) "self",(char *) "pos", NULL
40946 };
40947
40948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40950 if (!SWIG_IsOK(res1)) {
40951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40952 }
40953 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40954 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40955 if (!SWIG_IsOK(ecode2)) {
40956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40957 }
40958 arg2 = static_cast< size_t >(val2);
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 result = (wxMenu *)(arg1)->Remove(arg2);
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 {
40966 resultobj = wxPyMake_wxObject(result, 0);
40967 }
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40975 PyObject *resultobj = 0;
40976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40977 size_t arg2 ;
40978 bool arg3 ;
40979 void *argp1 = 0 ;
40980 int res1 = 0 ;
40981 size_t val2 ;
40982 int ecode2 = 0 ;
40983 bool val3 ;
40984 int ecode3 = 0 ;
40985 PyObject * obj0 = 0 ;
40986 PyObject * obj1 = 0 ;
40987 PyObject * obj2 = 0 ;
40988 char * kwnames[] = {
40989 (char *) "self",(char *) "pos",(char *) "enable", NULL
40990 };
40991
40992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40994 if (!SWIG_IsOK(res1)) {
40995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40996 }
40997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40998 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40999 if (!SWIG_IsOK(ecode2)) {
41000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41001 }
41002 arg2 = static_cast< size_t >(val2);
41003 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41004 if (!SWIG_IsOK(ecode3)) {
41005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41006 }
41007 arg3 = static_cast< bool >(val3);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 (arg1)->EnableTop(arg2,arg3);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 resultobj = SWIG_Py_Void();
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41022 PyObject *resultobj = 0;
41023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41024 size_t arg2 ;
41025 bool result;
41026 void *argp1 = 0 ;
41027 int res1 = 0 ;
41028 size_t val2 ;
41029 int ecode2 = 0 ;
41030 PyObject * obj0 = 0 ;
41031 PyObject * obj1 = 0 ;
41032 char * kwnames[] = {
41033 (char *) "self",(char *) "pos", NULL
41034 };
41035
41036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41038 if (!SWIG_IsOK(res1)) {
41039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41040 }
41041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41042 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41043 if (!SWIG_IsOK(ecode2)) {
41044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41045 }
41046 arg2 = static_cast< size_t >(val2);
41047 {
41048 PyThreadState* __tstate = wxPyBeginAllowThreads();
41049 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 {
41054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41055 }
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj = 0;
41064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41065 size_t arg2 ;
41066 wxString *arg3 = 0 ;
41067 void *argp1 = 0 ;
41068 int res1 = 0 ;
41069 size_t val2 ;
41070 int ecode2 = 0 ;
41071 bool temp3 = false ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 PyObject * obj2 = 0 ;
41075 char * kwnames[] = {
41076 (char *) "self",(char *) "pos",(char *) "label", NULL
41077 };
41078
41079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41085 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41086 if (!SWIG_IsOK(ecode2)) {
41087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41088 }
41089 arg2 = static_cast< size_t >(val2);
41090 {
41091 arg3 = wxString_in_helper(obj2);
41092 if (arg3 == NULL) SWIG_fail;
41093 temp3 = true;
41094 }
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41098 wxPyEndAllowThreads(__tstate);
41099 if (PyErr_Occurred()) SWIG_fail;
41100 }
41101 resultobj = SWIG_Py_Void();
41102 {
41103 if (temp3)
41104 delete arg3;
41105 }
41106 return resultobj;
41107 fail:
41108 {
41109 if (temp3)
41110 delete arg3;
41111 }
41112 return NULL;
41113 }
41114
41115
41116 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41117 PyObject *resultobj = 0;
41118 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41119 size_t arg2 ;
41120 wxString result;
41121 void *argp1 = 0 ;
41122 int res1 = 0 ;
41123 size_t val2 ;
41124 int ecode2 = 0 ;
41125 PyObject * obj0 = 0 ;
41126 PyObject * obj1 = 0 ;
41127 char * kwnames[] = {
41128 (char *) "self",(char *) "pos", NULL
41129 };
41130
41131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41133 if (!SWIG_IsOK(res1)) {
41134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41135 }
41136 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41137 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41138 if (!SWIG_IsOK(ecode2)) {
41139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41140 }
41141 arg2 = static_cast< size_t >(val2);
41142 {
41143 PyThreadState* __tstate = wxPyBeginAllowThreads();
41144 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 {
41149 #if wxUSE_UNICODE
41150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41151 #else
41152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41153 #endif
41154 }
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41162 PyObject *resultobj = 0;
41163 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41164 wxString *arg2 = 0 ;
41165 wxString *arg3 = 0 ;
41166 int result;
41167 void *argp1 = 0 ;
41168 int res1 = 0 ;
41169 bool temp2 = false ;
41170 bool temp3 = false ;
41171 PyObject * obj0 = 0 ;
41172 PyObject * obj1 = 0 ;
41173 PyObject * obj2 = 0 ;
41174 char * kwnames[] = {
41175 (char *) "self",(char *) "menu",(char *) "item", NULL
41176 };
41177
41178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41180 if (!SWIG_IsOK(res1)) {
41181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41182 }
41183 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41184 {
41185 arg2 = wxString_in_helper(obj1);
41186 if (arg2 == NULL) SWIG_fail;
41187 temp2 = true;
41188 }
41189 {
41190 arg3 = wxString_in_helper(obj2);
41191 if (arg3 == NULL) SWIG_fail;
41192 temp3 = true;
41193 }
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 resultobj = SWIG_From_int(static_cast< int >(result));
41201 {
41202 if (temp2)
41203 delete arg2;
41204 }
41205 {
41206 if (temp3)
41207 delete arg3;
41208 }
41209 return resultobj;
41210 fail:
41211 {
41212 if (temp2)
41213 delete arg2;
41214 }
41215 {
41216 if (temp3)
41217 delete arg3;
41218 }
41219 return NULL;
41220 }
41221
41222
41223 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41224 PyObject *resultobj = 0;
41225 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41226 int arg2 ;
41227 wxMenuItem *result = 0 ;
41228 void *argp1 = 0 ;
41229 int res1 = 0 ;
41230 int val2 ;
41231 int ecode2 = 0 ;
41232 PyObject * obj0 = 0 ;
41233 PyObject * obj1 = 0 ;
41234 char * kwnames[] = {
41235 (char *) "self",(char *) "id", NULL
41236 };
41237
41238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41240 if (!SWIG_IsOK(res1)) {
41241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41242 }
41243 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41244 ecode2 = SWIG_AsVal_int(obj1, &val2);
41245 if (!SWIG_IsOK(ecode2)) {
41246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41247 }
41248 arg2 = static_cast< int >(val2);
41249 {
41250 PyThreadState* __tstate = wxPyBeginAllowThreads();
41251 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41252 wxPyEndAllowThreads(__tstate);
41253 if (PyErr_Occurred()) SWIG_fail;
41254 }
41255 {
41256 resultobj = wxPyMake_wxObject(result, (bool)0);
41257 }
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = 0;
41266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41267 wxString *arg2 = 0 ;
41268 int result;
41269 void *argp1 = 0 ;
41270 int res1 = 0 ;
41271 bool temp2 = false ;
41272 PyObject * obj0 = 0 ;
41273 PyObject * obj1 = 0 ;
41274 char * kwnames[] = {
41275 (char *) "self",(char *) "title", NULL
41276 };
41277
41278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41280 if (!SWIG_IsOK(res1)) {
41281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41282 }
41283 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41284 {
41285 arg2 = wxString_in_helper(obj1);
41286 if (arg2 == NULL) SWIG_fail;
41287 temp2 = true;
41288 }
41289 {
41290 PyThreadState* __tstate = wxPyBeginAllowThreads();
41291 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41292 wxPyEndAllowThreads(__tstate);
41293 if (PyErr_Occurred()) SWIG_fail;
41294 }
41295 resultobj = SWIG_From_int(static_cast< int >(result));
41296 {
41297 if (temp2)
41298 delete arg2;
41299 }
41300 return resultobj;
41301 fail:
41302 {
41303 if (temp2)
41304 delete arg2;
41305 }
41306 return NULL;
41307 }
41308
41309
41310 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41311 PyObject *resultobj = 0;
41312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41313 int arg2 ;
41314 bool arg3 ;
41315 void *argp1 = 0 ;
41316 int res1 = 0 ;
41317 int val2 ;
41318 int ecode2 = 0 ;
41319 bool val3 ;
41320 int ecode3 = 0 ;
41321 PyObject * obj0 = 0 ;
41322 PyObject * obj1 = 0 ;
41323 PyObject * obj2 = 0 ;
41324 char * kwnames[] = {
41325 (char *) "self",(char *) "id",(char *) "enable", NULL
41326 };
41327
41328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41330 if (!SWIG_IsOK(res1)) {
41331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41332 }
41333 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41334 ecode2 = SWIG_AsVal_int(obj1, &val2);
41335 if (!SWIG_IsOK(ecode2)) {
41336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41337 }
41338 arg2 = static_cast< int >(val2);
41339 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41340 if (!SWIG_IsOK(ecode3)) {
41341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41342 }
41343 arg3 = static_cast< bool >(val3);
41344 {
41345 PyThreadState* __tstate = wxPyBeginAllowThreads();
41346 (arg1)->Enable(arg2,arg3);
41347 wxPyEndAllowThreads(__tstate);
41348 if (PyErr_Occurred()) SWIG_fail;
41349 }
41350 resultobj = SWIG_Py_Void();
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj = 0;
41359 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41360 int arg2 ;
41361 bool arg3 ;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 int val2 ;
41365 int ecode2 = 0 ;
41366 bool val3 ;
41367 int ecode3 = 0 ;
41368 PyObject * obj0 = 0 ;
41369 PyObject * obj1 = 0 ;
41370 PyObject * obj2 = 0 ;
41371 char * kwnames[] = {
41372 (char *) "self",(char *) "id",(char *) "check", NULL
41373 };
41374
41375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41377 if (!SWIG_IsOK(res1)) {
41378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41379 }
41380 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41381 ecode2 = SWIG_AsVal_int(obj1, &val2);
41382 if (!SWIG_IsOK(ecode2)) {
41383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41384 }
41385 arg2 = static_cast< int >(val2);
41386 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41387 if (!SWIG_IsOK(ecode3)) {
41388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41389 }
41390 arg3 = static_cast< bool >(val3);
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 (arg1)->Check(arg2,arg3);
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 resultobj = SWIG_Py_Void();
41398 return resultobj;
41399 fail:
41400 return NULL;
41401 }
41402
41403
41404 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41405 PyObject *resultobj = 0;
41406 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41407 int arg2 ;
41408 bool result;
41409 void *argp1 = 0 ;
41410 int res1 = 0 ;
41411 int val2 ;
41412 int ecode2 = 0 ;
41413 PyObject * obj0 = 0 ;
41414 PyObject * obj1 = 0 ;
41415 char * kwnames[] = {
41416 (char *) "self",(char *) "id", NULL
41417 };
41418
41419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41421 if (!SWIG_IsOK(res1)) {
41422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41423 }
41424 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41425 ecode2 = SWIG_AsVal_int(obj1, &val2);
41426 if (!SWIG_IsOK(ecode2)) {
41427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41428 }
41429 arg2 = static_cast< int >(val2);
41430 {
41431 PyThreadState* __tstate = wxPyBeginAllowThreads();
41432 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41433 wxPyEndAllowThreads(__tstate);
41434 if (PyErr_Occurred()) SWIG_fail;
41435 }
41436 {
41437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41438 }
41439 return resultobj;
41440 fail:
41441 return NULL;
41442 }
41443
41444
41445 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41446 PyObject *resultobj = 0;
41447 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41448 int arg2 ;
41449 bool result;
41450 void *argp1 = 0 ;
41451 int res1 = 0 ;
41452 int val2 ;
41453 int ecode2 = 0 ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "self",(char *) "id", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41462 if (!SWIG_IsOK(res1)) {
41463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41464 }
41465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41466 ecode2 = SWIG_AsVal_int(obj1, &val2);
41467 if (!SWIG_IsOK(ecode2)) {
41468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41469 }
41470 arg2 = static_cast< int >(val2);
41471 {
41472 PyThreadState* __tstate = wxPyBeginAllowThreads();
41473 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 {
41478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = 0;
41488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41489 int arg2 ;
41490 wxString *arg3 = 0 ;
41491 void *argp1 = 0 ;
41492 int res1 = 0 ;
41493 int val2 ;
41494 int ecode2 = 0 ;
41495 bool temp3 = false ;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 PyObject * obj2 = 0 ;
41499 char * kwnames[] = {
41500 (char *) "self",(char *) "id",(char *) "label", NULL
41501 };
41502
41503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41505 if (!SWIG_IsOK(res1)) {
41506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41507 }
41508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41509 ecode2 = SWIG_AsVal_int(obj1, &val2);
41510 if (!SWIG_IsOK(ecode2)) {
41511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41512 }
41513 arg2 = static_cast< int >(val2);
41514 {
41515 arg3 = wxString_in_helper(obj2);
41516 if (arg3 == NULL) SWIG_fail;
41517 temp3 = true;
41518 }
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 resultobj = SWIG_Py_Void();
41526 {
41527 if (temp3)
41528 delete arg3;
41529 }
41530 return resultobj;
41531 fail:
41532 {
41533 if (temp3)
41534 delete arg3;
41535 }
41536 return NULL;
41537 }
41538
41539
41540 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41541 PyObject *resultobj = 0;
41542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41543 int arg2 ;
41544 wxString result;
41545 void *argp1 = 0 ;
41546 int res1 = 0 ;
41547 int val2 ;
41548 int ecode2 = 0 ;
41549 PyObject * obj0 = 0 ;
41550 PyObject * obj1 = 0 ;
41551 char * kwnames[] = {
41552 (char *) "self",(char *) "id", NULL
41553 };
41554
41555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41557 if (!SWIG_IsOK(res1)) {
41558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41559 }
41560 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41561 ecode2 = SWIG_AsVal_int(obj1, &val2);
41562 if (!SWIG_IsOK(ecode2)) {
41563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41564 }
41565 arg2 = static_cast< int >(val2);
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41569 wxPyEndAllowThreads(__tstate);
41570 if (PyErr_Occurred()) SWIG_fail;
41571 }
41572 {
41573 #if wxUSE_UNICODE
41574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41575 #else
41576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41577 #endif
41578 }
41579 return resultobj;
41580 fail:
41581 return NULL;
41582 }
41583
41584
41585 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41586 PyObject *resultobj = 0;
41587 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41588 int arg2 ;
41589 wxString *arg3 = 0 ;
41590 void *argp1 = 0 ;
41591 int res1 = 0 ;
41592 int val2 ;
41593 int ecode2 = 0 ;
41594 bool temp3 = false ;
41595 PyObject * obj0 = 0 ;
41596 PyObject * obj1 = 0 ;
41597 PyObject * obj2 = 0 ;
41598 char * kwnames[] = {
41599 (char *) "self",(char *) "id",(char *) "helpString", NULL
41600 };
41601
41602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41604 if (!SWIG_IsOK(res1)) {
41605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41606 }
41607 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41608 ecode2 = SWIG_AsVal_int(obj1, &val2);
41609 if (!SWIG_IsOK(ecode2)) {
41610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41611 }
41612 arg2 = static_cast< int >(val2);
41613 {
41614 arg3 = wxString_in_helper(obj2);
41615 if (arg3 == NULL) SWIG_fail;
41616 temp3 = true;
41617 }
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 resultobj = SWIG_Py_Void();
41625 {
41626 if (temp3)
41627 delete arg3;
41628 }
41629 return resultobj;
41630 fail:
41631 {
41632 if (temp3)
41633 delete arg3;
41634 }
41635 return NULL;
41636 }
41637
41638
41639 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41640 PyObject *resultobj = 0;
41641 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41642 int arg2 ;
41643 wxString result;
41644 void *argp1 = 0 ;
41645 int res1 = 0 ;
41646 int val2 ;
41647 int ecode2 = 0 ;
41648 PyObject * obj0 = 0 ;
41649 PyObject * obj1 = 0 ;
41650 char * kwnames[] = {
41651 (char *) "self",(char *) "id", NULL
41652 };
41653
41654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41656 if (!SWIG_IsOK(res1)) {
41657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41658 }
41659 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41660 ecode2 = SWIG_AsVal_int(obj1, &val2);
41661 if (!SWIG_IsOK(ecode2)) {
41662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41663 }
41664 arg2 = static_cast< int >(val2);
41665 {
41666 PyThreadState* __tstate = wxPyBeginAllowThreads();
41667 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 {
41672 #if wxUSE_UNICODE
41673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41674 #else
41675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41676 #endif
41677 }
41678 return resultobj;
41679 fail:
41680 return NULL;
41681 }
41682
41683
41684 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41685 PyObject *resultobj = 0;
41686 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41687 wxFrame *result = 0 ;
41688 void *argp1 = 0 ;
41689 int res1 = 0 ;
41690 PyObject *swig_obj[1] ;
41691
41692 if (!args) SWIG_fail;
41693 swig_obj[0] = args;
41694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41695 if (!SWIG_IsOK(res1)) {
41696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41697 }
41698 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41699 {
41700 PyThreadState* __tstate = wxPyBeginAllowThreads();
41701 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41702 wxPyEndAllowThreads(__tstate);
41703 if (PyErr_Occurred()) SWIG_fail;
41704 }
41705 {
41706 resultobj = wxPyMake_wxObject(result, (bool)0);
41707 }
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41715 PyObject *resultobj = 0;
41716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41717 bool result;
41718 void *argp1 = 0 ;
41719 int res1 = 0 ;
41720 PyObject *swig_obj[1] ;
41721
41722 if (!args) SWIG_fail;
41723 swig_obj[0] = args;
41724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41725 if (!SWIG_IsOK(res1)) {
41726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41727 }
41728 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41729 {
41730 PyThreadState* __tstate = wxPyBeginAllowThreads();
41731 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 {
41736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41737 }
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj = 0;
41746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41747 wxFrame *arg2 = (wxFrame *) 0 ;
41748 void *argp1 = 0 ;
41749 int res1 = 0 ;
41750 void *argp2 = 0 ;
41751 int res2 = 0 ;
41752 PyObject * obj0 = 0 ;
41753 PyObject * obj1 = 0 ;
41754 char * kwnames[] = {
41755 (char *) "self",(char *) "frame", NULL
41756 };
41757
41758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41760 if (!SWIG_IsOK(res1)) {
41761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41762 }
41763 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41765 if (!SWIG_IsOK(res2)) {
41766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41767 }
41768 arg2 = reinterpret_cast< wxFrame * >(argp2);
41769 {
41770 PyThreadState* __tstate = wxPyBeginAllowThreads();
41771 (arg1)->Attach(arg2);
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 resultobj = SWIG_Py_Void();
41776 return resultobj;
41777 fail:
41778 return NULL;
41779 }
41780
41781
41782 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41783 PyObject *resultobj = 0;
41784 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41785 void *argp1 = 0 ;
41786 int res1 = 0 ;
41787 PyObject *swig_obj[1] ;
41788
41789 if (!args) SWIG_fail;
41790 swig_obj[0] = args;
41791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41792 if (!SWIG_IsOK(res1)) {
41793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41794 }
41795 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 (arg1)->Detach();
41799 wxPyEndAllowThreads(__tstate);
41800 if (PyErr_Occurred()) SWIG_fail;
41801 }
41802 resultobj = SWIG_Py_Void();
41803 return resultobj;
41804 fail:
41805 return NULL;
41806 }
41807
41808
41809 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41810 PyObject *resultobj = 0;
41811 bool arg1 ;
41812 bool val1 ;
41813 int ecode1 = 0 ;
41814 PyObject * obj0 = 0 ;
41815 char * kwnames[] = {
41816 (char *) "enable", NULL
41817 };
41818
41819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41820 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41821 if (!SWIG_IsOK(ecode1)) {
41822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41823 }
41824 arg1 = static_cast< bool >(val1);
41825 {
41826 PyThreadState* __tstate = wxPyBeginAllowThreads();
41827 wxMenuBar_SetAutoWindowMenu(arg1);
41828 wxPyEndAllowThreads(__tstate);
41829 if (PyErr_Occurred()) SWIG_fail;
41830 }
41831 resultobj = SWIG_Py_Void();
41832 return resultobj;
41833 fail:
41834 return NULL;
41835 }
41836
41837
41838 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41839 PyObject *resultobj = 0;
41840 bool result;
41841
41842 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41843 {
41844 PyThreadState* __tstate = wxPyBeginAllowThreads();
41845 result = (bool)wxMenuBar_GetAutoWindowMenu();
41846 wxPyEndAllowThreads(__tstate);
41847 if (PyErr_Occurred()) SWIG_fail;
41848 }
41849 {
41850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41851 }
41852 return resultobj;
41853 fail:
41854 return NULL;
41855 }
41856
41857
41858 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41859 PyObject *obj;
41860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41861 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41862 return SWIG_Py_Void();
41863 }
41864
41865 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41866 return SWIG_Python_InitShadowInstance(args);
41867 }
41868
41869 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41870 PyObject *resultobj = 0;
41871 wxMenu *arg1 = (wxMenu *) NULL ;
41872 int arg2 = (int) wxID_ANY ;
41873 wxString const &arg3_defvalue = wxPyEmptyString ;
41874 wxString *arg3 = (wxString *) &arg3_defvalue ;
41875 wxString const &arg4_defvalue = wxPyEmptyString ;
41876 wxString *arg4 = (wxString *) &arg4_defvalue ;
41877 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41878 wxMenu *arg6 = (wxMenu *) NULL ;
41879 wxMenuItem *result = 0 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 int val2 ;
41883 int ecode2 = 0 ;
41884 bool temp3 = false ;
41885 bool temp4 = false ;
41886 int val5 ;
41887 int ecode5 = 0 ;
41888 void *argp6 = 0 ;
41889 int res6 = 0 ;
41890 PyObject * obj0 = 0 ;
41891 PyObject * obj1 = 0 ;
41892 PyObject * obj2 = 0 ;
41893 PyObject * obj3 = 0 ;
41894 PyObject * obj4 = 0 ;
41895 PyObject * obj5 = 0 ;
41896 char * kwnames[] = {
41897 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41898 };
41899
41900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41901 if (obj0) {
41902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41903 if (!SWIG_IsOK(res1)) {
41904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41905 }
41906 arg1 = reinterpret_cast< wxMenu * >(argp1);
41907 }
41908 if (obj1) {
41909 ecode2 = SWIG_AsVal_int(obj1, &val2);
41910 if (!SWIG_IsOK(ecode2)) {
41911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41912 }
41913 arg2 = static_cast< int >(val2);
41914 }
41915 if (obj2) {
41916 {
41917 arg3 = wxString_in_helper(obj2);
41918 if (arg3 == NULL) SWIG_fail;
41919 temp3 = true;
41920 }
41921 }
41922 if (obj3) {
41923 {
41924 arg4 = wxString_in_helper(obj3);
41925 if (arg4 == NULL) SWIG_fail;
41926 temp4 = true;
41927 }
41928 }
41929 if (obj4) {
41930 ecode5 = SWIG_AsVal_int(obj4, &val5);
41931 if (!SWIG_IsOK(ecode5)) {
41932 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41933 }
41934 arg5 = static_cast< wxItemKind >(val5);
41935 }
41936 if (obj5) {
41937 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41938 if (!SWIG_IsOK(res6)) {
41939 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41940 }
41941 arg6 = reinterpret_cast< wxMenu * >(argp6);
41942 }
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 {
41950 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41951 }
41952 {
41953 if (temp3)
41954 delete arg3;
41955 }
41956 {
41957 if (temp4)
41958 delete arg4;
41959 }
41960 return resultobj;
41961 fail:
41962 {
41963 if (temp3)
41964 delete arg3;
41965 }
41966 {
41967 if (temp4)
41968 delete arg4;
41969 }
41970 return NULL;
41971 }
41972
41973
41974 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41975 PyObject *resultobj = 0;
41976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41977 void *argp1 = 0 ;
41978 int res1 = 0 ;
41979 PyObject *swig_obj[1] ;
41980
41981 if (!args) SWIG_fail;
41982 swig_obj[0] = args;
41983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41984 if (!SWIG_IsOK(res1)) {
41985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41986 }
41987 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41988 {
41989 PyThreadState* __tstate = wxPyBeginAllowThreads();
41990 delete arg1;
41991
41992 wxPyEndAllowThreads(__tstate);
41993 if (PyErr_Occurred()) SWIG_fail;
41994 }
41995 resultobj = SWIG_Py_Void();
41996 return resultobj;
41997 fail:
41998 return NULL;
41999 }
42000
42001
42002 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42003 PyObject *resultobj = 0;
42004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42005 wxMenu *result = 0 ;
42006 void *argp1 = 0 ;
42007 int res1 = 0 ;
42008 PyObject *swig_obj[1] ;
42009
42010 if (!args) SWIG_fail;
42011 swig_obj[0] = args;
42012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42013 if (!SWIG_IsOK(res1)) {
42014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42015 }
42016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42017 {
42018 PyThreadState* __tstate = wxPyBeginAllowThreads();
42019 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 {
42024 resultobj = wxPyMake_wxObject(result, 0);
42025 }
42026 return resultobj;
42027 fail:
42028 return NULL;
42029 }
42030
42031
42032 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42033 PyObject *resultobj = 0;
42034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42035 wxMenu *arg2 = (wxMenu *) 0 ;
42036 void *argp1 = 0 ;
42037 int res1 = 0 ;
42038 void *argp2 = 0 ;
42039 int res2 = 0 ;
42040 PyObject * obj0 = 0 ;
42041 PyObject * obj1 = 0 ;
42042 char * kwnames[] = {
42043 (char *) "self",(char *) "menu", NULL
42044 };
42045
42046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42048 if (!SWIG_IsOK(res1)) {
42049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42050 }
42051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42053 if (!SWIG_IsOK(res2)) {
42054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42055 }
42056 arg2 = reinterpret_cast< wxMenu * >(argp2);
42057 {
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 (arg1)->SetMenu(arg2);
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 resultobj = SWIG_Py_Void();
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj = 0;
42072 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42073 int arg2 ;
42074 void *argp1 = 0 ;
42075 int res1 = 0 ;
42076 int val2 ;
42077 int ecode2 = 0 ;
42078 PyObject * obj0 = 0 ;
42079 PyObject * obj1 = 0 ;
42080 char * kwnames[] = {
42081 (char *) "self",(char *) "id", NULL
42082 };
42083
42084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42086 if (!SWIG_IsOK(res1)) {
42087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42088 }
42089 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42090 ecode2 = SWIG_AsVal_int(obj1, &val2);
42091 if (!SWIG_IsOK(ecode2)) {
42092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42093 }
42094 arg2 = static_cast< int >(val2);
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 (arg1)->SetId(arg2);
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 resultobj = SWIG_Py_Void();
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42109 PyObject *resultobj = 0;
42110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42111 int result;
42112 void *argp1 = 0 ;
42113 int res1 = 0 ;
42114 PyObject *swig_obj[1] ;
42115
42116 if (!args) SWIG_fail;
42117 swig_obj[0] = args;
42118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42119 if (!SWIG_IsOK(res1)) {
42120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42121 }
42122 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 result = (int)((wxMenuItem const *)arg1)->GetId();
42126 wxPyEndAllowThreads(__tstate);
42127 if (PyErr_Occurred()) SWIG_fail;
42128 }
42129 resultobj = SWIG_From_int(static_cast< int >(result));
42130 return resultobj;
42131 fail:
42132 return NULL;
42133 }
42134
42135
42136 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42137 PyObject *resultobj = 0;
42138 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42139 bool result;
42140 void *argp1 = 0 ;
42141 int res1 = 0 ;
42142 PyObject *swig_obj[1] ;
42143
42144 if (!args) SWIG_fail;
42145 swig_obj[0] = args;
42146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42147 if (!SWIG_IsOK(res1)) {
42148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42149 }
42150 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42151 {
42152 PyThreadState* __tstate = wxPyBeginAllowThreads();
42153 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42154 wxPyEndAllowThreads(__tstate);
42155 if (PyErr_Occurred()) SWIG_fail;
42156 }
42157 {
42158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42159 }
42160 return resultobj;
42161 fail:
42162 return NULL;
42163 }
42164
42165
42166 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42167 PyObject *resultobj = 0;
42168 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42169 wxString *arg2 = 0 ;
42170 void *argp1 = 0 ;
42171 int res1 = 0 ;
42172 bool temp2 = false ;
42173 PyObject * obj0 = 0 ;
42174 PyObject * obj1 = 0 ;
42175 char * kwnames[] = {
42176 (char *) "self",(char *) "str", NULL
42177 };
42178
42179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42181 if (!SWIG_IsOK(res1)) {
42182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42183 }
42184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42185 {
42186 arg2 = wxString_in_helper(obj1);
42187 if (arg2 == NULL) SWIG_fail;
42188 temp2 = true;
42189 }
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 (arg1)->SetText((wxString const &)*arg2);
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 resultobj = SWIG_Py_Void();
42197 {
42198 if (temp2)
42199 delete arg2;
42200 }
42201 return resultobj;
42202 fail:
42203 {
42204 if (temp2)
42205 delete arg2;
42206 }
42207 return NULL;
42208 }
42209
42210
42211 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42212 PyObject *resultobj = 0;
42213 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42214 wxString result;
42215 void *argp1 = 0 ;
42216 int res1 = 0 ;
42217 PyObject *swig_obj[1] ;
42218
42219 if (!args) SWIG_fail;
42220 swig_obj[0] = args;
42221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42222 if (!SWIG_IsOK(res1)) {
42223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42224 }
42225 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 result = ((wxMenuItem const *)arg1)->GetLabel();
42229 wxPyEndAllowThreads(__tstate);
42230 if (PyErr_Occurred()) SWIG_fail;
42231 }
42232 {
42233 #if wxUSE_UNICODE
42234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42235 #else
42236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42237 #endif
42238 }
42239 return resultobj;
42240 fail:
42241 return NULL;
42242 }
42243
42244
42245 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42246 PyObject *resultobj = 0;
42247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42248 wxString *result = 0 ;
42249 void *argp1 = 0 ;
42250 int res1 = 0 ;
42251 PyObject *swig_obj[1] ;
42252
42253 if (!args) SWIG_fail;
42254 swig_obj[0] = args;
42255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42256 if (!SWIG_IsOK(res1)) {
42257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42258 }
42259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42260 {
42261 PyThreadState* __tstate = wxPyBeginAllowThreads();
42262 {
42263 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42264 result = (wxString *) &_result_ref;
42265 }
42266 wxPyEndAllowThreads(__tstate);
42267 if (PyErr_Occurred()) SWIG_fail;
42268 }
42269 {
42270 #if wxUSE_UNICODE
42271 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42272 #else
42273 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42274 #endif
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj = 0;
42284 wxString *arg1 = 0 ;
42285 wxString result;
42286 bool temp1 = false ;
42287 PyObject * obj0 = 0 ;
42288 char * kwnames[] = {
42289 (char *) "text", NULL
42290 };
42291
42292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42293 {
42294 arg1 = wxString_in_helper(obj0);
42295 if (arg1 == NULL) SWIG_fail;
42296 temp1 = true;
42297 }
42298 {
42299 PyThreadState* __tstate = wxPyBeginAllowThreads();
42300 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 {
42305 #if wxUSE_UNICODE
42306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42307 #else
42308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42309 #endif
42310 }
42311 {
42312 if (temp1)
42313 delete arg1;
42314 }
42315 return resultobj;
42316 fail:
42317 {
42318 if (temp1)
42319 delete arg1;
42320 }
42321 return NULL;
42322 }
42323
42324
42325 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42326 PyObject *resultobj = 0;
42327 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42328 wxItemKind result;
42329 void *argp1 = 0 ;
42330 int res1 = 0 ;
42331 PyObject *swig_obj[1] ;
42332
42333 if (!args) SWIG_fail;
42334 swig_obj[0] = args;
42335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42336 if (!SWIG_IsOK(res1)) {
42337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42338 }
42339 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42340 {
42341 PyThreadState* __tstate = wxPyBeginAllowThreads();
42342 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42343 wxPyEndAllowThreads(__tstate);
42344 if (PyErr_Occurred()) SWIG_fail;
42345 }
42346 resultobj = SWIG_From_int(static_cast< int >(result));
42347 return resultobj;
42348 fail:
42349 return NULL;
42350 }
42351
42352
42353 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42354 PyObject *resultobj = 0;
42355 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42356 wxItemKind arg2 ;
42357 void *argp1 = 0 ;
42358 int res1 = 0 ;
42359 int val2 ;
42360 int ecode2 = 0 ;
42361 PyObject * obj0 = 0 ;
42362 PyObject * obj1 = 0 ;
42363 char * kwnames[] = {
42364 (char *) "self",(char *) "kind", NULL
42365 };
42366
42367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42369 if (!SWIG_IsOK(res1)) {
42370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42371 }
42372 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42373 ecode2 = SWIG_AsVal_int(obj1, &val2);
42374 if (!SWIG_IsOK(ecode2)) {
42375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42376 }
42377 arg2 = static_cast< wxItemKind >(val2);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 (arg1)->SetKind(arg2);
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 resultobj = SWIG_Py_Void();
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = 0;
42393 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42394 bool arg2 ;
42395 void *argp1 = 0 ;
42396 int res1 = 0 ;
42397 bool val2 ;
42398 int ecode2 = 0 ;
42399 PyObject * obj0 = 0 ;
42400 PyObject * obj1 = 0 ;
42401 char * kwnames[] = {
42402 (char *) "self",(char *) "checkable", NULL
42403 };
42404
42405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42407 if (!SWIG_IsOK(res1)) {
42408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42409 }
42410 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42411 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42412 if (!SWIG_IsOK(ecode2)) {
42413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42414 }
42415 arg2 = static_cast< bool >(val2);
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 (arg1)->SetCheckable(arg2);
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 resultobj = SWIG_Py_Void();
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42430 PyObject *resultobj = 0;
42431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42432 bool result;
42433 void *argp1 = 0 ;
42434 int res1 = 0 ;
42435 PyObject *swig_obj[1] ;
42436
42437 if (!args) SWIG_fail;
42438 swig_obj[0] = args;
42439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42440 if (!SWIG_IsOK(res1)) {
42441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42442 }
42443 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42444 {
42445 PyThreadState* __tstate = wxPyBeginAllowThreads();
42446 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 {
42451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42452 }
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42460 PyObject *resultobj = 0;
42461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42462 bool result;
42463 void *argp1 = 0 ;
42464 int res1 = 0 ;
42465 PyObject *swig_obj[1] ;
42466
42467 if (!args) SWIG_fail;
42468 swig_obj[0] = args;
42469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42470 if (!SWIG_IsOK(res1)) {
42471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42472 }
42473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42474 {
42475 PyThreadState* __tstate = wxPyBeginAllowThreads();
42476 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 {
42481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42482 }
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = 0;
42491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42492 wxMenu *arg2 = (wxMenu *) 0 ;
42493 void *argp1 = 0 ;
42494 int res1 = 0 ;
42495 void *argp2 = 0 ;
42496 int res2 = 0 ;
42497 PyObject * obj0 = 0 ;
42498 PyObject * obj1 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "menu", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42510 if (!SWIG_IsOK(res2)) {
42511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42512 }
42513 arg2 = reinterpret_cast< wxMenu * >(argp2);
42514 {
42515 PyThreadState* __tstate = wxPyBeginAllowThreads();
42516 (arg1)->SetSubMenu(arg2);
42517 wxPyEndAllowThreads(__tstate);
42518 if (PyErr_Occurred()) SWIG_fail;
42519 }
42520 resultobj = SWIG_Py_Void();
42521 return resultobj;
42522 fail:
42523 return NULL;
42524 }
42525
42526
42527 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42528 PyObject *resultobj = 0;
42529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42530 wxMenu *result = 0 ;
42531 void *argp1 = 0 ;
42532 int res1 = 0 ;
42533 PyObject *swig_obj[1] ;
42534
42535 if (!args) SWIG_fail;
42536 swig_obj[0] = args;
42537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42538 if (!SWIG_IsOK(res1)) {
42539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42540 }
42541 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42542 {
42543 PyThreadState* __tstate = wxPyBeginAllowThreads();
42544 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42545 wxPyEndAllowThreads(__tstate);
42546 if (PyErr_Occurred()) SWIG_fail;
42547 }
42548 {
42549 resultobj = wxPyMake_wxObject(result, 0);
42550 }
42551 return resultobj;
42552 fail:
42553 return NULL;
42554 }
42555
42556
42557 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42558 PyObject *resultobj = 0;
42559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42560 bool arg2 = (bool) true ;
42561 void *argp1 = 0 ;
42562 int res1 = 0 ;
42563 bool val2 ;
42564 int ecode2 = 0 ;
42565 PyObject * obj0 = 0 ;
42566 PyObject * obj1 = 0 ;
42567 char * kwnames[] = {
42568 (char *) "self",(char *) "enable", NULL
42569 };
42570
42571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42573 if (!SWIG_IsOK(res1)) {
42574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42575 }
42576 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42577 if (obj1) {
42578 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42579 if (!SWIG_IsOK(ecode2)) {
42580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42581 }
42582 arg2 = static_cast< bool >(val2);
42583 }
42584 {
42585 PyThreadState* __tstate = wxPyBeginAllowThreads();
42586 (arg1)->Enable(arg2);
42587 wxPyEndAllowThreads(__tstate);
42588 if (PyErr_Occurred()) SWIG_fail;
42589 }
42590 resultobj = SWIG_Py_Void();
42591 return resultobj;
42592 fail:
42593 return NULL;
42594 }
42595
42596
42597 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42598 PyObject *resultobj = 0;
42599 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42600 bool result;
42601 void *argp1 = 0 ;
42602 int res1 = 0 ;
42603 PyObject *swig_obj[1] ;
42604
42605 if (!args) SWIG_fail;
42606 swig_obj[0] = args;
42607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42608 if (!SWIG_IsOK(res1)) {
42609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42610 }
42611 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42612 {
42613 PyThreadState* __tstate = wxPyBeginAllowThreads();
42614 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42615 wxPyEndAllowThreads(__tstate);
42616 if (PyErr_Occurred()) SWIG_fail;
42617 }
42618 {
42619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42620 }
42621 return resultobj;
42622 fail:
42623 return NULL;
42624 }
42625
42626
42627 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42628 PyObject *resultobj = 0;
42629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42630 bool arg2 = (bool) true ;
42631 void *argp1 = 0 ;
42632 int res1 = 0 ;
42633 bool val2 ;
42634 int ecode2 = 0 ;
42635 PyObject * obj0 = 0 ;
42636 PyObject * obj1 = 0 ;
42637 char * kwnames[] = {
42638 (char *) "self",(char *) "check", NULL
42639 };
42640
42641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42643 if (!SWIG_IsOK(res1)) {
42644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42645 }
42646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42647 if (obj1) {
42648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42649 if (!SWIG_IsOK(ecode2)) {
42650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42651 }
42652 arg2 = static_cast< bool >(val2);
42653 }
42654 {
42655 PyThreadState* __tstate = wxPyBeginAllowThreads();
42656 (arg1)->Check(arg2);
42657 wxPyEndAllowThreads(__tstate);
42658 if (PyErr_Occurred()) SWIG_fail;
42659 }
42660 resultobj = SWIG_Py_Void();
42661 return resultobj;
42662 fail:
42663 return NULL;
42664 }
42665
42666
42667 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42668 PyObject *resultobj = 0;
42669 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42670 bool result;
42671 void *argp1 = 0 ;
42672 int res1 = 0 ;
42673 PyObject *swig_obj[1] ;
42674
42675 if (!args) SWIG_fail;
42676 swig_obj[0] = args;
42677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42678 if (!SWIG_IsOK(res1)) {
42679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42680 }
42681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42682 {
42683 PyThreadState* __tstate = wxPyBeginAllowThreads();
42684 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 {
42689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42690 }
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42698 PyObject *resultobj = 0;
42699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42700 void *argp1 = 0 ;
42701 int res1 = 0 ;
42702 PyObject *swig_obj[1] ;
42703
42704 if (!args) SWIG_fail;
42705 swig_obj[0] = args;
42706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42707 if (!SWIG_IsOK(res1)) {
42708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42709 }
42710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 (arg1)->Toggle();
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 resultobj = SWIG_Py_Void();
42718 return resultobj;
42719 fail:
42720 return NULL;
42721 }
42722
42723
42724 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42725 PyObject *resultobj = 0;
42726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42727 wxString *arg2 = 0 ;
42728 void *argp1 = 0 ;
42729 int res1 = 0 ;
42730 bool temp2 = false ;
42731 PyObject * obj0 = 0 ;
42732 PyObject * obj1 = 0 ;
42733 char * kwnames[] = {
42734 (char *) "self",(char *) "str", NULL
42735 };
42736
42737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 {
42744 arg2 = wxString_in_helper(obj1);
42745 if (arg2 == NULL) SWIG_fail;
42746 temp2 = true;
42747 }
42748 {
42749 PyThreadState* __tstate = wxPyBeginAllowThreads();
42750 (arg1)->SetHelp((wxString const &)*arg2);
42751 wxPyEndAllowThreads(__tstate);
42752 if (PyErr_Occurred()) SWIG_fail;
42753 }
42754 resultobj = SWIG_Py_Void();
42755 {
42756 if (temp2)
42757 delete arg2;
42758 }
42759 return resultobj;
42760 fail:
42761 {
42762 if (temp2)
42763 delete arg2;
42764 }
42765 return NULL;
42766 }
42767
42768
42769 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42770 PyObject *resultobj = 0;
42771 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42772 wxString *result = 0 ;
42773 void *argp1 = 0 ;
42774 int res1 = 0 ;
42775 PyObject *swig_obj[1] ;
42776
42777 if (!args) SWIG_fail;
42778 swig_obj[0] = args;
42779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42780 if (!SWIG_IsOK(res1)) {
42781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42782 }
42783 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42784 {
42785 PyThreadState* __tstate = wxPyBeginAllowThreads();
42786 {
42787 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42788 result = (wxString *) &_result_ref;
42789 }
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 {
42794 #if wxUSE_UNICODE
42795 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42796 #else
42797 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42798 #endif
42799 }
42800 return resultobj;
42801 fail:
42802 return NULL;
42803 }
42804
42805
42806 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42807 PyObject *resultobj = 0;
42808 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42809 wxAcceleratorEntry *result = 0 ;
42810 void *argp1 = 0 ;
42811 int res1 = 0 ;
42812 PyObject *swig_obj[1] ;
42813
42814 if (!args) SWIG_fail;
42815 swig_obj[0] = args;
42816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42817 if (!SWIG_IsOK(res1)) {
42818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42819 }
42820 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42821 {
42822 PyThreadState* __tstate = wxPyBeginAllowThreads();
42823 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42824 wxPyEndAllowThreads(__tstate);
42825 if (PyErr_Occurred()) SWIG_fail;
42826 }
42827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42835 PyObject *resultobj = 0;
42836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42837 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42838 void *argp1 = 0 ;
42839 int res1 = 0 ;
42840 void *argp2 = 0 ;
42841 int res2 = 0 ;
42842 PyObject * obj0 = 0 ;
42843 PyObject * obj1 = 0 ;
42844 char * kwnames[] = {
42845 (char *) "self",(char *) "accel", NULL
42846 };
42847
42848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42850 if (!SWIG_IsOK(res1)) {
42851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42852 }
42853 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42855 if (!SWIG_IsOK(res2)) {
42856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42857 }
42858 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42859 {
42860 PyThreadState* __tstate = wxPyBeginAllowThreads();
42861 (arg1)->SetAccel(arg2);
42862 wxPyEndAllowThreads(__tstate);
42863 if (PyErr_Occurred()) SWIG_fail;
42864 }
42865 resultobj = SWIG_Py_Void();
42866 return resultobj;
42867 fail:
42868 return NULL;
42869 }
42870
42871
42872 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42873 PyObject *resultobj = 0;
42874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42875 wxBitmap *arg2 = 0 ;
42876 void *argp1 = 0 ;
42877 int res1 = 0 ;
42878 void *argp2 = 0 ;
42879 int res2 = 0 ;
42880 PyObject * obj0 = 0 ;
42881 PyObject * obj1 = 0 ;
42882 char * kwnames[] = {
42883 (char *) "self",(char *) "bitmap", NULL
42884 };
42885
42886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42888 if (!SWIG_IsOK(res1)) {
42889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42890 }
42891 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42893 if (!SWIG_IsOK(res2)) {
42894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42895 }
42896 if (!argp2) {
42897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42898 }
42899 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42900 {
42901 PyThreadState* __tstate = wxPyBeginAllowThreads();
42902 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42903 wxPyEndAllowThreads(__tstate);
42904 if (PyErr_Occurred()) SWIG_fail;
42905 }
42906 resultobj = SWIG_Py_Void();
42907 return resultobj;
42908 fail:
42909 return NULL;
42910 }
42911
42912
42913 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42914 PyObject *resultobj = 0;
42915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42916 wxBitmap *result = 0 ;
42917 void *argp1 = 0 ;
42918 int res1 = 0 ;
42919 PyObject *swig_obj[1] ;
42920
42921 if (!args) SWIG_fail;
42922 swig_obj[0] = args;
42923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42924 if (!SWIG_IsOK(res1)) {
42925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42926 }
42927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42928 {
42929 PyThreadState* __tstate = wxPyBeginAllowThreads();
42930 {
42931 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42932 result = (wxBitmap *) &_result_ref;
42933 }
42934 wxPyEndAllowThreads(__tstate);
42935 if (PyErr_Occurred()) SWIG_fail;
42936 }
42937 {
42938 wxBitmap* resultptr = new wxBitmap(*result);
42939 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42940 }
42941 return resultobj;
42942 fail:
42943 return NULL;
42944 }
42945
42946
42947 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42948 PyObject *resultobj = 0;
42949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42950 wxFont *arg2 = 0 ;
42951 void *argp1 = 0 ;
42952 int res1 = 0 ;
42953 void *argp2 = 0 ;
42954 int res2 = 0 ;
42955 PyObject * obj0 = 0 ;
42956 PyObject * obj1 = 0 ;
42957 char * kwnames[] = {
42958 (char *) "self",(char *) "font", NULL
42959 };
42960
42961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42963 if (!SWIG_IsOK(res1)) {
42964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42965 }
42966 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42967 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42968 if (!SWIG_IsOK(res2)) {
42969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42970 }
42971 if (!argp2) {
42972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42973 }
42974 arg2 = reinterpret_cast< wxFont * >(argp2);
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42978 wxPyEndAllowThreads(__tstate);
42979 if (PyErr_Occurred()) SWIG_fail;
42980 }
42981 resultobj = SWIG_Py_Void();
42982 return resultobj;
42983 fail:
42984 return NULL;
42985 }
42986
42987
42988 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42989 PyObject *resultobj = 0;
42990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42991 wxFont result;
42992 void *argp1 = 0 ;
42993 int res1 = 0 ;
42994 PyObject *swig_obj[1] ;
42995
42996 if (!args) SWIG_fail;
42997 swig_obj[0] = args;
42998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42999 if (!SWIG_IsOK(res1)) {
43000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43001 }
43002 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43003 {
43004 PyThreadState* __tstate = wxPyBeginAllowThreads();
43005 result = wxMenuItem_GetFont(arg1);
43006 wxPyEndAllowThreads(__tstate);
43007 if (PyErr_Occurred()) SWIG_fail;
43008 }
43009 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43010 return resultobj;
43011 fail:
43012 return NULL;
43013 }
43014
43015
43016 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43017 PyObject *resultobj = 0;
43018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43019 wxColour *arg2 = 0 ;
43020 void *argp1 = 0 ;
43021 int res1 = 0 ;
43022 wxColour temp2 ;
43023 PyObject * obj0 = 0 ;
43024 PyObject * obj1 = 0 ;
43025 char * kwnames[] = {
43026 (char *) "self",(char *) "colText", NULL
43027 };
43028
43029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43031 if (!SWIG_IsOK(res1)) {
43032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43033 }
43034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43035 {
43036 arg2 = &temp2;
43037 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43038 }
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43042 wxPyEndAllowThreads(__tstate);
43043 if (PyErr_Occurred()) SWIG_fail;
43044 }
43045 resultobj = SWIG_Py_Void();
43046 return resultobj;
43047 fail:
43048 return NULL;
43049 }
43050
43051
43052 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43053 PyObject *resultobj = 0;
43054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43055 wxColour result;
43056 void *argp1 = 0 ;
43057 int res1 = 0 ;
43058 PyObject *swig_obj[1] ;
43059
43060 if (!args) SWIG_fail;
43061 swig_obj[0] = args;
43062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = wxMenuItem_GetTextColour(arg1);
43070 wxPyEndAllowThreads(__tstate);
43071 if (PyErr_Occurred()) SWIG_fail;
43072 }
43073 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43074 return resultobj;
43075 fail:
43076 return NULL;
43077 }
43078
43079
43080 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43081 PyObject *resultobj = 0;
43082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43083 wxColour *arg2 = 0 ;
43084 void *argp1 = 0 ;
43085 int res1 = 0 ;
43086 wxColour temp2 ;
43087 PyObject * obj0 = 0 ;
43088 PyObject * obj1 = 0 ;
43089 char * kwnames[] = {
43090 (char *) "self",(char *) "colBack", NULL
43091 };
43092
43093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43095 if (!SWIG_IsOK(res1)) {
43096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43097 }
43098 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43099 {
43100 arg2 = &temp2;
43101 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43102 }
43103 {
43104 PyThreadState* __tstate = wxPyBeginAllowThreads();
43105 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 resultobj = SWIG_Py_Void();
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43117 PyObject *resultobj = 0;
43118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43119 wxColour result;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 PyObject *swig_obj[1] ;
43123
43124 if (!args) SWIG_fail;
43125 swig_obj[0] = args;
43126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43127 if (!SWIG_IsOK(res1)) {
43128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43129 }
43130 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 result = wxMenuItem_GetBackgroundColour(arg1);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43145 PyObject *resultobj = 0;
43146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43147 wxBitmap *arg2 = 0 ;
43148 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43149 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43150 void *argp1 = 0 ;
43151 int res1 = 0 ;
43152 void *argp2 = 0 ;
43153 int res2 = 0 ;
43154 void *argp3 = 0 ;
43155 int res3 = 0 ;
43156 PyObject * obj0 = 0 ;
43157 PyObject * obj1 = 0 ;
43158 PyObject * obj2 = 0 ;
43159 char * kwnames[] = {
43160 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43161 };
43162
43163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43165 if (!SWIG_IsOK(res1)) {
43166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43167 }
43168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43170 if (!SWIG_IsOK(res2)) {
43171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43172 }
43173 if (!argp2) {
43174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43175 }
43176 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43177 if (obj2) {
43178 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43179 if (!SWIG_IsOK(res3)) {
43180 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43181 }
43182 if (!argp3) {
43183 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43184 }
43185 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43186 }
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43190 wxPyEndAllowThreads(__tstate);
43191 if (PyErr_Occurred()) SWIG_fail;
43192 }
43193 resultobj = SWIG_Py_Void();
43194 return resultobj;
43195 fail:
43196 return NULL;
43197 }
43198
43199
43200 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43201 PyObject *resultobj = 0;
43202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43203 wxBitmap *arg2 = 0 ;
43204 void *argp1 = 0 ;
43205 int res1 = 0 ;
43206 void *argp2 = 0 ;
43207 int res2 = 0 ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "bmpDisabled", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43221 if (!SWIG_IsOK(res2)) {
43222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43223 }
43224 if (!argp2) {
43225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43226 }
43227 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43228 {
43229 PyThreadState* __tstate = wxPyBeginAllowThreads();
43230 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43231 wxPyEndAllowThreads(__tstate);
43232 if (PyErr_Occurred()) SWIG_fail;
43233 }
43234 resultobj = SWIG_Py_Void();
43235 return resultobj;
43236 fail:
43237 return NULL;
43238 }
43239
43240
43241 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43242 PyObject *resultobj = 0;
43243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43244 wxBitmap *result = 0 ;
43245 void *argp1 = 0 ;
43246 int res1 = 0 ;
43247 PyObject *swig_obj[1] ;
43248
43249 if (!args) SWIG_fail;
43250 swig_obj[0] = args;
43251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43252 if (!SWIG_IsOK(res1)) {
43253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43254 }
43255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43256 {
43257 PyThreadState* __tstate = wxPyBeginAllowThreads();
43258 {
43259 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43260 result = (wxBitmap *) &_result_ref;
43261 }
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 wxBitmap* resultptr = new wxBitmap(*result);
43267 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43268 }
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43276 PyObject *resultobj = 0;
43277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43278 int arg2 ;
43279 void *argp1 = 0 ;
43280 int res1 = 0 ;
43281 int val2 ;
43282 int ecode2 = 0 ;
43283 PyObject * obj0 = 0 ;
43284 PyObject * obj1 = 0 ;
43285 char * kwnames[] = {
43286 (char *) "self",(char *) "nWidth", NULL
43287 };
43288
43289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43291 if (!SWIG_IsOK(res1)) {
43292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43293 }
43294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43295 ecode2 = SWIG_AsVal_int(obj1, &val2);
43296 if (!SWIG_IsOK(ecode2)) {
43297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43298 }
43299 arg2 = static_cast< int >(val2);
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 wxMenuItem_SetMarginWidth(arg1,arg2);
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 resultobj = SWIG_Py_Void();
43307 return resultobj;
43308 fail:
43309 return NULL;
43310 }
43311
43312
43313 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43314 PyObject *resultobj = 0;
43315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43316 int result;
43317 void *argp1 = 0 ;
43318 int res1 = 0 ;
43319 PyObject *swig_obj[1] ;
43320
43321 if (!args) SWIG_fail;
43322 swig_obj[0] = args;
43323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43324 if (!SWIG_IsOK(res1)) {
43325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43326 }
43327 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43328 {
43329 PyThreadState* __tstate = wxPyBeginAllowThreads();
43330 result = (int)wxMenuItem_GetMarginWidth(arg1);
43331 wxPyEndAllowThreads(__tstate);
43332 if (PyErr_Occurred()) SWIG_fail;
43333 }
43334 resultobj = SWIG_From_int(static_cast< int >(result));
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43342 PyObject *resultobj = 0;
43343 int result;
43344
43345 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = (int)wxMenuItem_GetDefaultMarginWidth();
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 resultobj = SWIG_From_int(static_cast< int >(result));
43353 return resultobj;
43354 fail:
43355 return NULL;
43356 }
43357
43358
43359 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43360 PyObject *resultobj = 0;
43361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43362 bool result;
43363 void *argp1 = 0 ;
43364 int res1 = 0 ;
43365 PyObject *swig_obj[1] ;
43366
43367 if (!args) SWIG_fail;
43368 swig_obj[0] = args;
43369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43370 if (!SWIG_IsOK(res1)) {
43371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43372 }
43373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 {
43381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43382 }
43383 return resultobj;
43384 fail:
43385 return NULL;
43386 }
43387
43388
43389 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43390 PyObject *resultobj = 0;
43391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43392 bool arg2 = (bool) true ;
43393 void *argp1 = 0 ;
43394 int res1 = 0 ;
43395 bool val2 ;
43396 int ecode2 = 0 ;
43397 PyObject * obj0 = 0 ;
43398 PyObject * obj1 = 0 ;
43399 char * kwnames[] = {
43400 (char *) "self",(char *) "ownerDrawn", NULL
43401 };
43402
43403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43405 if (!SWIG_IsOK(res1)) {
43406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43407 }
43408 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43409 if (obj1) {
43410 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43411 if (!SWIG_IsOK(ecode2)) {
43412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43413 }
43414 arg2 = static_cast< bool >(val2);
43415 }
43416 {
43417 PyThreadState* __tstate = wxPyBeginAllowThreads();
43418 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43419 wxPyEndAllowThreads(__tstate);
43420 if (PyErr_Occurred()) SWIG_fail;
43421 }
43422 resultobj = SWIG_Py_Void();
43423 return resultobj;
43424 fail:
43425 return NULL;
43426 }
43427
43428
43429 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43430 PyObject *resultobj = 0;
43431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43432 void *argp1 = 0 ;
43433 int res1 = 0 ;
43434 PyObject *swig_obj[1] ;
43435
43436 if (!args) SWIG_fail;
43437 swig_obj[0] = args;
43438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43439 if (!SWIG_IsOK(res1)) {
43440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43441 }
43442 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43443 {
43444 PyThreadState* __tstate = wxPyBeginAllowThreads();
43445 wxMenuItem_ResetOwnerDrawn(arg1);
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 resultobj = SWIG_Py_Void();
43450 return resultobj;
43451 fail:
43452 return NULL;
43453 }
43454
43455
43456 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43457 PyObject *obj;
43458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43459 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43460 return SWIG_Py_Void();
43461 }
43462
43463 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43464 return SWIG_Python_InitShadowInstance(args);
43465 }
43466
43467 SWIGINTERN int ControlNameStr_set(PyObject *) {
43468 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43469 return 1;
43470 }
43471
43472
43473 SWIGINTERN PyObject *ControlNameStr_get(void) {
43474 PyObject *pyobj = 0;
43475
43476 {
43477 #if wxUSE_UNICODE
43478 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43479 #else
43480 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43481 #endif
43482 }
43483 return pyobj;
43484 }
43485
43486
43487 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43488 PyObject *resultobj = 0;
43489 wxWindow *arg1 = (wxWindow *) 0 ;
43490 int arg2 = (int) -1 ;
43491 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43492 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43493 wxSize const &arg4_defvalue = wxDefaultSize ;
43494 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43495 long arg5 = (long) 0 ;
43496 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43497 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43498 wxString const &arg7_defvalue = wxPyControlNameStr ;
43499 wxString *arg7 = (wxString *) &arg7_defvalue ;
43500 wxControl *result = 0 ;
43501 void *argp1 = 0 ;
43502 int res1 = 0 ;
43503 int val2 ;
43504 int ecode2 = 0 ;
43505 wxPoint temp3 ;
43506 wxSize temp4 ;
43507 long val5 ;
43508 int ecode5 = 0 ;
43509 void *argp6 = 0 ;
43510 int res6 = 0 ;
43511 bool temp7 = false ;
43512 PyObject * obj0 = 0 ;
43513 PyObject * obj1 = 0 ;
43514 PyObject * obj2 = 0 ;
43515 PyObject * obj3 = 0 ;
43516 PyObject * obj4 = 0 ;
43517 PyObject * obj5 = 0 ;
43518 PyObject * obj6 = 0 ;
43519 char * kwnames[] = {
43520 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43521 };
43522
43523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43525 if (!SWIG_IsOK(res1)) {
43526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43527 }
43528 arg1 = reinterpret_cast< wxWindow * >(argp1);
43529 if (obj1) {
43530 ecode2 = SWIG_AsVal_int(obj1, &val2);
43531 if (!SWIG_IsOK(ecode2)) {
43532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43533 }
43534 arg2 = static_cast< int >(val2);
43535 }
43536 if (obj2) {
43537 {
43538 arg3 = &temp3;
43539 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43540 }
43541 }
43542 if (obj3) {
43543 {
43544 arg4 = &temp4;
43545 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43546 }
43547 }
43548 if (obj4) {
43549 ecode5 = SWIG_AsVal_long(obj4, &val5);
43550 if (!SWIG_IsOK(ecode5)) {
43551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43552 }
43553 arg5 = static_cast< long >(val5);
43554 }
43555 if (obj5) {
43556 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43557 if (!SWIG_IsOK(res6)) {
43558 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43559 }
43560 if (!argp6) {
43561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43562 }
43563 arg6 = reinterpret_cast< wxValidator * >(argp6);
43564 }
43565 if (obj6) {
43566 {
43567 arg7 = wxString_in_helper(obj6);
43568 if (arg7 == NULL) SWIG_fail;
43569 temp7 = true;
43570 }
43571 }
43572 {
43573 if (!wxPyCheckForApp()) SWIG_fail;
43574 PyThreadState* __tstate = wxPyBeginAllowThreads();
43575 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43576 wxPyEndAllowThreads(__tstate);
43577 if (PyErr_Occurred()) SWIG_fail;
43578 }
43579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43580 {
43581 if (temp7)
43582 delete arg7;
43583 }
43584 return resultobj;
43585 fail:
43586 {
43587 if (temp7)
43588 delete arg7;
43589 }
43590 return NULL;
43591 }
43592
43593
43594 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43595 PyObject *resultobj = 0;
43596 wxControl *result = 0 ;
43597
43598 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43599 {
43600 if (!wxPyCheckForApp()) SWIG_fail;
43601 PyThreadState* __tstate = wxPyBeginAllowThreads();
43602 result = (wxControl *)new wxControl();
43603 wxPyEndAllowThreads(__tstate);
43604 if (PyErr_Occurred()) SWIG_fail;
43605 }
43606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43614 PyObject *resultobj = 0;
43615 wxControl *arg1 = (wxControl *) 0 ;
43616 wxWindow *arg2 = (wxWindow *) 0 ;
43617 int arg3 = (int) -1 ;
43618 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43619 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43620 wxSize const &arg5_defvalue = wxDefaultSize ;
43621 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43622 long arg6 = (long) 0 ;
43623 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43624 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43625 wxString const &arg8_defvalue = wxPyControlNameStr ;
43626 wxString *arg8 = (wxString *) &arg8_defvalue ;
43627 bool result;
43628 void *argp1 = 0 ;
43629 int res1 = 0 ;
43630 void *argp2 = 0 ;
43631 int res2 = 0 ;
43632 int val3 ;
43633 int ecode3 = 0 ;
43634 wxPoint temp4 ;
43635 wxSize temp5 ;
43636 long val6 ;
43637 int ecode6 = 0 ;
43638 void *argp7 = 0 ;
43639 int res7 = 0 ;
43640 bool temp8 = false ;
43641 PyObject * obj0 = 0 ;
43642 PyObject * obj1 = 0 ;
43643 PyObject * obj2 = 0 ;
43644 PyObject * obj3 = 0 ;
43645 PyObject * obj4 = 0 ;
43646 PyObject * obj5 = 0 ;
43647 PyObject * obj6 = 0 ;
43648 PyObject * obj7 = 0 ;
43649 char * kwnames[] = {
43650 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43651 };
43652
43653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43655 if (!SWIG_IsOK(res1)) {
43656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43657 }
43658 arg1 = reinterpret_cast< wxControl * >(argp1);
43659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43660 if (!SWIG_IsOK(res2)) {
43661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43662 }
43663 arg2 = reinterpret_cast< wxWindow * >(argp2);
43664 if (obj2) {
43665 ecode3 = SWIG_AsVal_int(obj2, &val3);
43666 if (!SWIG_IsOK(ecode3)) {
43667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43668 }
43669 arg3 = static_cast< int >(val3);
43670 }
43671 if (obj3) {
43672 {
43673 arg4 = &temp4;
43674 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43675 }
43676 }
43677 if (obj4) {
43678 {
43679 arg5 = &temp5;
43680 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43681 }
43682 }
43683 if (obj5) {
43684 ecode6 = SWIG_AsVal_long(obj5, &val6);
43685 if (!SWIG_IsOK(ecode6)) {
43686 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43687 }
43688 arg6 = static_cast< long >(val6);
43689 }
43690 if (obj6) {
43691 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43692 if (!SWIG_IsOK(res7)) {
43693 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43694 }
43695 if (!argp7) {
43696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43697 }
43698 arg7 = reinterpret_cast< wxValidator * >(argp7);
43699 }
43700 if (obj7) {
43701 {
43702 arg8 = wxString_in_helper(obj7);
43703 if (arg8 == NULL) SWIG_fail;
43704 temp8 = true;
43705 }
43706 }
43707 {
43708 PyThreadState* __tstate = wxPyBeginAllowThreads();
43709 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43710 wxPyEndAllowThreads(__tstate);
43711 if (PyErr_Occurred()) SWIG_fail;
43712 }
43713 {
43714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43715 }
43716 {
43717 if (temp8)
43718 delete arg8;
43719 }
43720 return resultobj;
43721 fail:
43722 {
43723 if (temp8)
43724 delete arg8;
43725 }
43726 return NULL;
43727 }
43728
43729
43730 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43731 PyObject *resultobj = 0;
43732 wxControl *arg1 = (wxControl *) 0 ;
43733 wxCommandEvent *arg2 = 0 ;
43734 void *argp1 = 0 ;
43735 int res1 = 0 ;
43736 void *argp2 = 0 ;
43737 int res2 = 0 ;
43738 PyObject * obj0 = 0 ;
43739 PyObject * obj1 = 0 ;
43740 char * kwnames[] = {
43741 (char *) "self",(char *) "event", NULL
43742 };
43743
43744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43746 if (!SWIG_IsOK(res1)) {
43747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43748 }
43749 arg1 = reinterpret_cast< wxControl * >(argp1);
43750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43751 if (!SWIG_IsOK(res2)) {
43752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43753 }
43754 if (!argp2) {
43755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43756 }
43757 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43758 {
43759 PyThreadState* __tstate = wxPyBeginAllowThreads();
43760 (arg1)->Command(*arg2);
43761 wxPyEndAllowThreads(__tstate);
43762 if (PyErr_Occurred()) SWIG_fail;
43763 }
43764 resultobj = SWIG_Py_Void();
43765 return resultobj;
43766 fail:
43767 return NULL;
43768 }
43769
43770
43771 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43772 PyObject *resultobj = 0;
43773 wxControl *arg1 = (wxControl *) 0 ;
43774 wxString result;
43775 void *argp1 = 0 ;
43776 int res1 = 0 ;
43777 PyObject *swig_obj[1] ;
43778
43779 if (!args) SWIG_fail;
43780 swig_obj[0] = args;
43781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43782 if (!SWIG_IsOK(res1)) {
43783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43784 }
43785 arg1 = reinterpret_cast< wxControl * >(argp1);
43786 {
43787 PyThreadState* __tstate = wxPyBeginAllowThreads();
43788 result = (arg1)->GetLabel();
43789 wxPyEndAllowThreads(__tstate);
43790 if (PyErr_Occurred()) SWIG_fail;
43791 }
43792 {
43793 #if wxUSE_UNICODE
43794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43795 #else
43796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43797 #endif
43798 }
43799 return resultobj;
43800 fail:
43801 return NULL;
43802 }
43803
43804
43805 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43806 PyObject *resultobj = 0;
43807 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43808 SwigValueWrapper<wxVisualAttributes > result;
43809 int val1 ;
43810 int ecode1 = 0 ;
43811 PyObject * obj0 = 0 ;
43812 char * kwnames[] = {
43813 (char *) "variant", NULL
43814 };
43815
43816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43817 if (obj0) {
43818 ecode1 = SWIG_AsVal_int(obj0, &val1);
43819 if (!SWIG_IsOK(ecode1)) {
43820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43821 }
43822 arg1 = static_cast< wxWindowVariant >(val1);
43823 }
43824 {
43825 if (!wxPyCheckForApp()) SWIG_fail;
43826 PyThreadState* __tstate = wxPyBeginAllowThreads();
43827 result = wxControl::GetClassDefaultAttributes(arg1);
43828 wxPyEndAllowThreads(__tstate);
43829 if (PyErr_Occurred()) SWIG_fail;
43830 }
43831 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43832 return resultobj;
43833 fail:
43834 return NULL;
43835 }
43836
43837
43838 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43839 PyObject *obj;
43840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43841 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43842 return SWIG_Py_Void();
43843 }
43844
43845 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43846 return SWIG_Python_InitShadowInstance(args);
43847 }
43848
43849 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43850 PyObject *resultobj = 0;
43851 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43852 wxString *arg2 = 0 ;
43853 PyObject *arg3 = (PyObject *) NULL ;
43854 int result;
43855 void *argp1 = 0 ;
43856 int res1 = 0 ;
43857 bool temp2 = false ;
43858 PyObject * obj0 = 0 ;
43859 PyObject * obj1 = 0 ;
43860 PyObject * obj2 = 0 ;
43861 char * kwnames[] = {
43862 (char *) "self",(char *) "item",(char *) "clientData", NULL
43863 };
43864
43865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43867 if (!SWIG_IsOK(res1)) {
43868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43869 }
43870 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43871 {
43872 arg2 = wxString_in_helper(obj1);
43873 if (arg2 == NULL) SWIG_fail;
43874 temp2 = true;
43875 }
43876 if (obj2) {
43877 arg3 = obj2;
43878 }
43879 {
43880 PyThreadState* __tstate = wxPyBeginAllowThreads();
43881 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43882 wxPyEndAllowThreads(__tstate);
43883 if (PyErr_Occurred()) SWIG_fail;
43884 }
43885 resultobj = SWIG_From_int(static_cast< int >(result));
43886 {
43887 if (temp2)
43888 delete arg2;
43889 }
43890 return resultobj;
43891 fail:
43892 {
43893 if (temp2)
43894 delete arg2;
43895 }
43896 return NULL;
43897 }
43898
43899
43900 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj = 0;
43902 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43903 wxArrayString *arg2 = 0 ;
43904 void *argp1 = 0 ;
43905 int res1 = 0 ;
43906 bool temp2 = false ;
43907 PyObject * obj0 = 0 ;
43908 PyObject * obj1 = 0 ;
43909 char * kwnames[] = {
43910 (char *) "self",(char *) "strings", NULL
43911 };
43912
43913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43915 if (!SWIG_IsOK(res1)) {
43916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43917 }
43918 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43919 {
43920 if (! PySequence_Check(obj1)) {
43921 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43922 SWIG_fail;
43923 }
43924 arg2 = new wxArrayString;
43925 temp2 = true;
43926 int i, len=PySequence_Length(obj1);
43927 for (i=0; i<len; i++) {
43928 PyObject* item = PySequence_GetItem(obj1, i);
43929 wxString* s = wxString_in_helper(item);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 arg2->Add(*s);
43932 delete s;
43933 Py_DECREF(item);
43934 }
43935 }
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 (arg1)->Append((wxArrayString const &)*arg2);
43939 wxPyEndAllowThreads(__tstate);
43940 if (PyErr_Occurred()) SWIG_fail;
43941 }
43942 resultobj = SWIG_Py_Void();
43943 {
43944 if (temp2) delete arg2;
43945 }
43946 return resultobj;
43947 fail:
43948 {
43949 if (temp2) delete arg2;
43950 }
43951 return NULL;
43952 }
43953
43954
43955 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43956 PyObject *resultobj = 0;
43957 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43958 wxString *arg2 = 0 ;
43959 unsigned int arg3 ;
43960 PyObject *arg4 = (PyObject *) NULL ;
43961 int result;
43962 void *argp1 = 0 ;
43963 int res1 = 0 ;
43964 bool temp2 = false ;
43965 unsigned int val3 ;
43966 int ecode3 = 0 ;
43967 PyObject * obj0 = 0 ;
43968 PyObject * obj1 = 0 ;
43969 PyObject * obj2 = 0 ;
43970 PyObject * obj3 = 0 ;
43971 char * kwnames[] = {
43972 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43973 };
43974
43975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43977 if (!SWIG_IsOK(res1)) {
43978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43979 }
43980 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43981 {
43982 arg2 = wxString_in_helper(obj1);
43983 if (arg2 == NULL) SWIG_fail;
43984 temp2 = true;
43985 }
43986 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
43987 if (!SWIG_IsOK(ecode3)) {
43988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
43989 }
43990 arg3 = static_cast< unsigned int >(val3);
43991 if (obj3) {
43992 arg4 = obj3;
43993 }
43994 {
43995 PyThreadState* __tstate = wxPyBeginAllowThreads();
43996 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 resultobj = SWIG_From_int(static_cast< int >(result));
44001 {
44002 if (temp2)
44003 delete arg2;
44004 }
44005 return resultobj;
44006 fail:
44007 {
44008 if (temp2)
44009 delete arg2;
44010 }
44011 return NULL;
44012 }
44013
44014
44015 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44016 PyObject *resultobj = 0;
44017 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44018 void *argp1 = 0 ;
44019 int res1 = 0 ;
44020 PyObject *swig_obj[1] ;
44021
44022 if (!args) SWIG_fail;
44023 swig_obj[0] = args;
44024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44025 if (!SWIG_IsOK(res1)) {
44026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44027 }
44028 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44029 {
44030 PyThreadState* __tstate = wxPyBeginAllowThreads();
44031 (arg1)->Clear();
44032 wxPyEndAllowThreads(__tstate);
44033 if (PyErr_Occurred()) SWIG_fail;
44034 }
44035 resultobj = SWIG_Py_Void();
44036 return resultobj;
44037 fail:
44038 return NULL;
44039 }
44040
44041
44042 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44043 PyObject *resultobj = 0;
44044 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44045 unsigned int arg2 ;
44046 void *argp1 = 0 ;
44047 int res1 = 0 ;
44048 unsigned int val2 ;
44049 int ecode2 = 0 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 char * kwnames[] = {
44053 (char *) "self",(char *) "n", NULL
44054 };
44055
44056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44058 if (!SWIG_IsOK(res1)) {
44059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44060 }
44061 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44062 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44063 if (!SWIG_IsOK(ecode2)) {
44064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44065 }
44066 arg2 = static_cast< unsigned int >(val2);
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 (arg1)->Delete(arg2);
44070 wxPyEndAllowThreads(__tstate);
44071 if (PyErr_Occurred()) SWIG_fail;
44072 }
44073 resultobj = SWIG_Py_Void();
44074 return resultobj;
44075 fail:
44076 return NULL;
44077 }
44078
44079
44080 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44081 PyObject *resultobj = 0;
44082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44083 unsigned int arg2 ;
44084 PyObject *result = 0 ;
44085 void *argp1 = 0 ;
44086 int res1 = 0 ;
44087 unsigned int val2 ;
44088 int ecode2 = 0 ;
44089 PyObject * obj0 = 0 ;
44090 PyObject * obj1 = 0 ;
44091 char * kwnames[] = {
44092 (char *) "self",(char *) "n", NULL
44093 };
44094
44095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44097 if (!SWIG_IsOK(res1)) {
44098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44099 }
44100 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44101 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44102 if (!SWIG_IsOK(ecode2)) {
44103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44104 }
44105 arg2 = static_cast< unsigned int >(val2);
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 resultobj = result;
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44120 PyObject *resultobj = 0;
44121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44122 unsigned int arg2 ;
44123 PyObject *arg3 = (PyObject *) 0 ;
44124 void *argp1 = 0 ;
44125 int res1 = 0 ;
44126 unsigned int val2 ;
44127 int ecode2 = 0 ;
44128 PyObject * obj0 = 0 ;
44129 PyObject * obj1 = 0 ;
44130 PyObject * obj2 = 0 ;
44131 char * kwnames[] = {
44132 (char *) "self",(char *) "n",(char *) "clientData", NULL
44133 };
44134
44135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44137 if (!SWIG_IsOK(res1)) {
44138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44139 }
44140 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44141 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44142 if (!SWIG_IsOK(ecode2)) {
44143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44144 }
44145 arg2 = static_cast< unsigned int >(val2);
44146 arg3 = obj2;
44147 {
44148 PyThreadState* __tstate = wxPyBeginAllowThreads();
44149 wxItemContainer_SetClientData(arg1,arg2,arg3);
44150 wxPyEndAllowThreads(__tstate);
44151 if (PyErr_Occurred()) SWIG_fail;
44152 }
44153 resultobj = SWIG_Py_Void();
44154 return resultobj;
44155 fail:
44156 return NULL;
44157 }
44158
44159
44160 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44161 PyObject *resultobj = 0;
44162 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44163 unsigned int result;
44164 void *argp1 = 0 ;
44165 int res1 = 0 ;
44166 PyObject *swig_obj[1] ;
44167
44168 if (!args) SWIG_fail;
44169 swig_obj[0] = args;
44170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44171 if (!SWIG_IsOK(res1)) {
44172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44173 }
44174 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44175 {
44176 PyThreadState* __tstate = wxPyBeginAllowThreads();
44177 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44182 return resultobj;
44183 fail:
44184 return NULL;
44185 }
44186
44187
44188 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44189 PyObject *resultobj = 0;
44190 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44191 bool result;
44192 void *argp1 = 0 ;
44193 int res1 = 0 ;
44194 PyObject *swig_obj[1] ;
44195
44196 if (!args) SWIG_fail;
44197 swig_obj[0] = args;
44198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44199 if (!SWIG_IsOK(res1)) {
44200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44201 }
44202 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44203 {
44204 PyThreadState* __tstate = wxPyBeginAllowThreads();
44205 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44206 wxPyEndAllowThreads(__tstate);
44207 if (PyErr_Occurred()) SWIG_fail;
44208 }
44209 {
44210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44211 }
44212 return resultobj;
44213 fail:
44214 return NULL;
44215 }
44216
44217
44218 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44219 PyObject *resultobj = 0;
44220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44221 unsigned int arg2 ;
44222 wxString result;
44223 void *argp1 = 0 ;
44224 int res1 = 0 ;
44225 unsigned int val2 ;
44226 int ecode2 = 0 ;
44227 PyObject * obj0 = 0 ;
44228 PyObject * obj1 = 0 ;
44229 char * kwnames[] = {
44230 (char *) "self",(char *) "n", NULL
44231 };
44232
44233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44235 if (!SWIG_IsOK(res1)) {
44236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44237 }
44238 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44239 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44240 if (!SWIG_IsOK(ecode2)) {
44241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44242 }
44243 arg2 = static_cast< unsigned int >(val2);
44244 {
44245 PyThreadState* __tstate = wxPyBeginAllowThreads();
44246 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44247 wxPyEndAllowThreads(__tstate);
44248 if (PyErr_Occurred()) SWIG_fail;
44249 }
44250 {
44251 #if wxUSE_UNICODE
44252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44253 #else
44254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44255 #endif
44256 }
44257 return resultobj;
44258 fail:
44259 return NULL;
44260 }
44261
44262
44263 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44264 PyObject *resultobj = 0;
44265 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44266 wxArrayString result;
44267 void *argp1 = 0 ;
44268 int res1 = 0 ;
44269 PyObject *swig_obj[1] ;
44270
44271 if (!args) SWIG_fail;
44272 swig_obj[0] = args;
44273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44274 if (!SWIG_IsOK(res1)) {
44275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44276 }
44277 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44278 {
44279 PyThreadState* __tstate = wxPyBeginAllowThreads();
44280 result = ((wxItemContainer const *)arg1)->GetStrings();
44281 wxPyEndAllowThreads(__tstate);
44282 if (PyErr_Occurred()) SWIG_fail;
44283 }
44284 {
44285 resultobj = wxArrayString2PyList_helper(result);
44286 }
44287 return resultobj;
44288 fail:
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44294 PyObject *resultobj = 0;
44295 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44296 unsigned int arg2 ;
44297 wxString *arg3 = 0 ;
44298 void *argp1 = 0 ;
44299 int res1 = 0 ;
44300 unsigned int val2 ;
44301 int ecode2 = 0 ;
44302 bool temp3 = false ;
44303 PyObject * obj0 = 0 ;
44304 PyObject * obj1 = 0 ;
44305 PyObject * obj2 = 0 ;
44306 char * kwnames[] = {
44307 (char *) "self",(char *) "n",(char *) "s", NULL
44308 };
44309
44310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44312 if (!SWIG_IsOK(res1)) {
44313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44314 }
44315 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44316 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44317 if (!SWIG_IsOK(ecode2)) {
44318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44319 }
44320 arg2 = static_cast< unsigned int >(val2);
44321 {
44322 arg3 = wxString_in_helper(obj2);
44323 if (arg3 == NULL) SWIG_fail;
44324 temp3 = true;
44325 }
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 (arg1)->SetString(arg2,(wxString const &)*arg3);
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 resultobj = SWIG_Py_Void();
44333 {
44334 if (temp3)
44335 delete arg3;
44336 }
44337 return resultobj;
44338 fail:
44339 {
44340 if (temp3)
44341 delete arg3;
44342 }
44343 return NULL;
44344 }
44345
44346
44347 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44348 PyObject *resultobj = 0;
44349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44350 wxString *arg2 = 0 ;
44351 int result;
44352 void *argp1 = 0 ;
44353 int res1 = 0 ;
44354 bool temp2 = false ;
44355 PyObject * obj0 = 0 ;
44356 PyObject * obj1 = 0 ;
44357 char * kwnames[] = {
44358 (char *) "self",(char *) "s", NULL
44359 };
44360
44361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44363 if (!SWIG_IsOK(res1)) {
44364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44365 }
44366 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44367 {
44368 arg2 = wxString_in_helper(obj1);
44369 if (arg2 == NULL) SWIG_fail;
44370 temp2 = true;
44371 }
44372 {
44373 PyThreadState* __tstate = wxPyBeginAllowThreads();
44374 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44375 wxPyEndAllowThreads(__tstate);
44376 if (PyErr_Occurred()) SWIG_fail;
44377 }
44378 resultobj = SWIG_From_int(static_cast< int >(result));
44379 {
44380 if (temp2)
44381 delete arg2;
44382 }
44383 return resultobj;
44384 fail:
44385 {
44386 if (temp2)
44387 delete arg2;
44388 }
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44396 int arg2 ;
44397 void *argp1 = 0 ;
44398 int res1 = 0 ;
44399 int val2 ;
44400 int ecode2 = 0 ;
44401 PyObject * obj0 = 0 ;
44402 PyObject * obj1 = 0 ;
44403 char * kwnames[] = {
44404 (char *) "self",(char *) "n", NULL
44405 };
44406
44407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44409 if (!SWIG_IsOK(res1)) {
44410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44411 }
44412 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44413 ecode2 = SWIG_AsVal_int(obj1, &val2);
44414 if (!SWIG_IsOK(ecode2)) {
44415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44416 }
44417 arg2 = static_cast< int >(val2);
44418 {
44419 PyThreadState* __tstate = wxPyBeginAllowThreads();
44420 (arg1)->SetSelection(arg2);
44421 wxPyEndAllowThreads(__tstate);
44422 if (PyErr_Occurred()) SWIG_fail;
44423 }
44424 resultobj = SWIG_Py_Void();
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44432 PyObject *resultobj = 0;
44433 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44434 int result;
44435 void *argp1 = 0 ;
44436 int res1 = 0 ;
44437 PyObject *swig_obj[1] ;
44438
44439 if (!args) SWIG_fail;
44440 swig_obj[0] = args;
44441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44442 if (!SWIG_IsOK(res1)) {
44443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44444 }
44445 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_From_int(static_cast< int >(result));
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44460 PyObject *resultobj = 0;
44461 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44462 wxString *arg2 = 0 ;
44463 bool result;
44464 void *argp1 = 0 ;
44465 int res1 = 0 ;
44466 bool temp2 = false ;
44467 PyObject * obj0 = 0 ;
44468 PyObject * obj1 = 0 ;
44469 char * kwnames[] = {
44470 (char *) "self",(char *) "s", NULL
44471 };
44472
44473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44475 if (!SWIG_IsOK(res1)) {
44476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44477 }
44478 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44479 {
44480 arg2 = wxString_in_helper(obj1);
44481 if (arg2 == NULL) SWIG_fail;
44482 temp2 = true;
44483 }
44484 {
44485 PyThreadState* __tstate = wxPyBeginAllowThreads();
44486 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44487 wxPyEndAllowThreads(__tstate);
44488 if (PyErr_Occurred()) SWIG_fail;
44489 }
44490 {
44491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44492 }
44493 {
44494 if (temp2)
44495 delete arg2;
44496 }
44497 return resultobj;
44498 fail:
44499 {
44500 if (temp2)
44501 delete arg2;
44502 }
44503 return NULL;
44504 }
44505
44506
44507 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44508 PyObject *resultobj = 0;
44509 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44510 wxString result;
44511 void *argp1 = 0 ;
44512 int res1 = 0 ;
44513 PyObject *swig_obj[1] ;
44514
44515 if (!args) SWIG_fail;
44516 swig_obj[0] = args;
44517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44518 if (!SWIG_IsOK(res1)) {
44519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44520 }
44521 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 {
44529 #if wxUSE_UNICODE
44530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44531 #else
44532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44533 #endif
44534 }
44535 return resultobj;
44536 fail:
44537 return NULL;
44538 }
44539
44540
44541 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44542 PyObject *resultobj = 0;
44543 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44544 int arg2 ;
44545 void *argp1 = 0 ;
44546 int res1 = 0 ;
44547 int val2 ;
44548 int ecode2 = 0 ;
44549 PyObject * obj0 = 0 ;
44550 PyObject * obj1 = 0 ;
44551 char * kwnames[] = {
44552 (char *) "self",(char *) "n", NULL
44553 };
44554
44555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44557 if (!SWIG_IsOK(res1)) {
44558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44559 }
44560 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44561 ecode2 = SWIG_AsVal_int(obj1, &val2);
44562 if (!SWIG_IsOK(ecode2)) {
44563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44564 }
44565 arg2 = static_cast< int >(val2);
44566 {
44567 PyThreadState* __tstate = wxPyBeginAllowThreads();
44568 (arg1)->Select(arg2);
44569 wxPyEndAllowThreads(__tstate);
44570 if (PyErr_Occurred()) SWIG_fail;
44571 }
44572 resultobj = SWIG_Py_Void();
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44580 PyObject *obj;
44581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44582 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44583 return SWIG_Py_Void();
44584 }
44585
44586 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44587 PyObject *obj;
44588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44589 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44590 return SWIG_Py_Void();
44591 }
44592
44593 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44594 PyObject *resultobj = 0;
44595 wxSizerItem *result = 0 ;
44596
44597 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 result = (wxSizerItem *)new wxSizerItem();
44601 wxPyEndAllowThreads(__tstate);
44602 if (PyErr_Occurred()) SWIG_fail;
44603 }
44604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44605 return resultobj;
44606 fail:
44607 return NULL;
44608 }
44609
44610
44611 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44612 PyObject *resultobj = 0;
44613 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44614 void *argp1 = 0 ;
44615 int res1 = 0 ;
44616 PyObject *swig_obj[1] ;
44617
44618 if (!args) SWIG_fail;
44619 swig_obj[0] = args;
44620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44621 if (!SWIG_IsOK(res1)) {
44622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44623 }
44624 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44625 {
44626 PyThreadState* __tstate = wxPyBeginAllowThreads();
44627 delete arg1;
44628
44629 wxPyEndAllowThreads(__tstate);
44630 if (PyErr_Occurred()) SWIG_fail;
44631 }
44632 resultobj = SWIG_Py_Void();
44633 return resultobj;
44634 fail:
44635 return NULL;
44636 }
44637
44638
44639 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44640 PyObject *resultobj = 0;
44641 wxWindow *arg1 = (wxWindow *) 0 ;
44642 int arg2 ;
44643 int arg3 ;
44644 int arg4 ;
44645 PyObject *arg5 = (PyObject *) NULL ;
44646 wxSizerItem *result = 0 ;
44647 void *argp1 = 0 ;
44648 int res1 = 0 ;
44649 int val2 ;
44650 int ecode2 = 0 ;
44651 int val3 ;
44652 int ecode3 = 0 ;
44653 int val4 ;
44654 int ecode4 = 0 ;
44655 PyObject * obj0 = 0 ;
44656 PyObject * obj1 = 0 ;
44657 PyObject * obj2 = 0 ;
44658 PyObject * obj3 = 0 ;
44659 PyObject * obj4 = 0 ;
44660 char * kwnames[] = {
44661 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44662 };
44663
44664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44666 if (!SWIG_IsOK(res1)) {
44667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44668 }
44669 arg1 = reinterpret_cast< wxWindow * >(argp1);
44670 ecode2 = SWIG_AsVal_int(obj1, &val2);
44671 if (!SWIG_IsOK(ecode2)) {
44672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44673 }
44674 arg2 = static_cast< int >(val2);
44675 ecode3 = SWIG_AsVal_int(obj2, &val3);
44676 if (!SWIG_IsOK(ecode3)) {
44677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44678 }
44679 arg3 = static_cast< int >(val3);
44680 ecode4 = SWIG_AsVal_int(obj3, &val4);
44681 if (!SWIG_IsOK(ecode4)) {
44682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44683 }
44684 arg4 = static_cast< int >(val4);
44685 if (obj4) {
44686 arg5 = obj4;
44687 }
44688 {
44689 PyThreadState* __tstate = wxPyBeginAllowThreads();
44690 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44691 wxPyEndAllowThreads(__tstate);
44692 if (PyErr_Occurred()) SWIG_fail;
44693 }
44694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44695 return resultobj;
44696 fail:
44697 return NULL;
44698 }
44699
44700
44701 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44702 PyObject *resultobj = 0;
44703 int arg1 ;
44704 int arg2 ;
44705 int arg3 ;
44706 int arg4 ;
44707 int arg5 ;
44708 PyObject *arg6 = (PyObject *) NULL ;
44709 wxSizerItem *result = 0 ;
44710 int val1 ;
44711 int ecode1 = 0 ;
44712 int val2 ;
44713 int ecode2 = 0 ;
44714 int val3 ;
44715 int ecode3 = 0 ;
44716 int val4 ;
44717 int ecode4 = 0 ;
44718 int val5 ;
44719 int ecode5 = 0 ;
44720 PyObject * obj0 = 0 ;
44721 PyObject * obj1 = 0 ;
44722 PyObject * obj2 = 0 ;
44723 PyObject * obj3 = 0 ;
44724 PyObject * obj4 = 0 ;
44725 PyObject * obj5 = 0 ;
44726 char * kwnames[] = {
44727 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44728 };
44729
44730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44731 ecode1 = SWIG_AsVal_int(obj0, &val1);
44732 if (!SWIG_IsOK(ecode1)) {
44733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44734 }
44735 arg1 = static_cast< int >(val1);
44736 ecode2 = SWIG_AsVal_int(obj1, &val2);
44737 if (!SWIG_IsOK(ecode2)) {
44738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44739 }
44740 arg2 = static_cast< int >(val2);
44741 ecode3 = SWIG_AsVal_int(obj2, &val3);
44742 if (!SWIG_IsOK(ecode3)) {
44743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44744 }
44745 arg3 = static_cast< int >(val3);
44746 ecode4 = SWIG_AsVal_int(obj3, &val4);
44747 if (!SWIG_IsOK(ecode4)) {
44748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44749 }
44750 arg4 = static_cast< int >(val4);
44751 ecode5 = SWIG_AsVal_int(obj4, &val5);
44752 if (!SWIG_IsOK(ecode5)) {
44753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44754 }
44755 arg5 = static_cast< int >(val5);
44756 if (obj5) {
44757 arg6 = obj5;
44758 }
44759 {
44760 PyThreadState* __tstate = wxPyBeginAllowThreads();
44761 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44762 wxPyEndAllowThreads(__tstate);
44763 if (PyErr_Occurred()) SWIG_fail;
44764 }
44765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44766 return resultobj;
44767 fail:
44768 return NULL;
44769 }
44770
44771
44772 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44773 PyObject *resultobj = 0;
44774 wxSizer *arg1 = (wxSizer *) 0 ;
44775 int arg2 ;
44776 int arg3 ;
44777 int arg4 ;
44778 PyObject *arg5 = (PyObject *) NULL ;
44779 wxSizerItem *result = 0 ;
44780 int res1 = 0 ;
44781 int val2 ;
44782 int ecode2 = 0 ;
44783 int val3 ;
44784 int ecode3 = 0 ;
44785 int val4 ;
44786 int ecode4 = 0 ;
44787 PyObject * obj0 = 0 ;
44788 PyObject * obj1 = 0 ;
44789 PyObject * obj2 = 0 ;
44790 PyObject * obj3 = 0 ;
44791 PyObject * obj4 = 0 ;
44792 char * kwnames[] = {
44793 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44794 };
44795
44796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44797 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44798 if (!SWIG_IsOK(res1)) {
44799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44800 }
44801 ecode2 = SWIG_AsVal_int(obj1, &val2);
44802 if (!SWIG_IsOK(ecode2)) {
44803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44804 }
44805 arg2 = static_cast< int >(val2);
44806 ecode3 = SWIG_AsVal_int(obj2, &val3);
44807 if (!SWIG_IsOK(ecode3)) {
44808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44809 }
44810 arg3 = static_cast< int >(val3);
44811 ecode4 = SWIG_AsVal_int(obj3, &val4);
44812 if (!SWIG_IsOK(ecode4)) {
44813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44814 }
44815 arg4 = static_cast< int >(val4);
44816 if (obj4) {
44817 arg5 = obj4;
44818 }
44819 {
44820 PyThreadState* __tstate = wxPyBeginAllowThreads();
44821 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44822 wxPyEndAllowThreads(__tstate);
44823 if (PyErr_Occurred()) SWIG_fail;
44824 }
44825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44826 return resultobj;
44827 fail:
44828 return NULL;
44829 }
44830
44831
44832 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44833 PyObject *resultobj = 0;
44834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44835 void *argp1 = 0 ;
44836 int res1 = 0 ;
44837 PyObject *swig_obj[1] ;
44838
44839 if (!args) SWIG_fail;
44840 swig_obj[0] = args;
44841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44842 if (!SWIG_IsOK(res1)) {
44843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44844 }
44845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44846 {
44847 PyThreadState* __tstate = wxPyBeginAllowThreads();
44848 (arg1)->DeleteWindows();
44849 wxPyEndAllowThreads(__tstate);
44850 if (PyErr_Occurred()) SWIG_fail;
44851 }
44852 resultobj = SWIG_Py_Void();
44853 return resultobj;
44854 fail:
44855 return NULL;
44856 }
44857
44858
44859 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44860 PyObject *resultobj = 0;
44861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44862 void *argp1 = 0 ;
44863 int res1 = 0 ;
44864 PyObject *swig_obj[1] ;
44865
44866 if (!args) SWIG_fail;
44867 swig_obj[0] = args;
44868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44869 if (!SWIG_IsOK(res1)) {
44870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44871 }
44872 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44873 {
44874 PyThreadState* __tstate = wxPyBeginAllowThreads();
44875 (arg1)->DetachSizer();
44876 wxPyEndAllowThreads(__tstate);
44877 if (PyErr_Occurred()) SWIG_fail;
44878 }
44879 resultobj = SWIG_Py_Void();
44880 return resultobj;
44881 fail:
44882 return NULL;
44883 }
44884
44885
44886 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44887 PyObject *resultobj = 0;
44888 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44889 wxSize result;
44890 void *argp1 = 0 ;
44891 int res1 = 0 ;
44892 PyObject *swig_obj[1] ;
44893
44894 if (!args) SWIG_fail;
44895 swig_obj[0] = args;
44896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44897 if (!SWIG_IsOK(res1)) {
44898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44899 }
44900 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44901 {
44902 PyThreadState* __tstate = wxPyBeginAllowThreads();
44903 result = (arg1)->GetSize();
44904 wxPyEndAllowThreads(__tstate);
44905 if (PyErr_Occurred()) SWIG_fail;
44906 }
44907 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44908 return resultobj;
44909 fail:
44910 return NULL;
44911 }
44912
44913
44914 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44915 PyObject *resultobj = 0;
44916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44917 wxSize result;
44918 void *argp1 = 0 ;
44919 int res1 = 0 ;
44920 PyObject *swig_obj[1] ;
44921
44922 if (!args) SWIG_fail;
44923 swig_obj[0] = args;
44924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44925 if (!SWIG_IsOK(res1)) {
44926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44927 }
44928 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (arg1)->CalcMin();
44932 wxPyEndAllowThreads(__tstate);
44933 if (PyErr_Occurred()) SWIG_fail;
44934 }
44935 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44936 return resultobj;
44937 fail:
44938 return NULL;
44939 }
44940
44941
44942 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44943 PyObject *resultobj = 0;
44944 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44945 wxPoint *arg2 = 0 ;
44946 wxSize *arg3 = 0 ;
44947 void *argp1 = 0 ;
44948 int res1 = 0 ;
44949 wxPoint temp2 ;
44950 wxSize temp3 ;
44951 PyObject * obj0 = 0 ;
44952 PyObject * obj1 = 0 ;
44953 PyObject * obj2 = 0 ;
44954 char * kwnames[] = {
44955 (char *) "self",(char *) "pos",(char *) "size", NULL
44956 };
44957
44958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44960 if (!SWIG_IsOK(res1)) {
44961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44962 }
44963 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44964 {
44965 arg2 = &temp2;
44966 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44967 }
44968 {
44969 arg3 = &temp3;
44970 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44971 }
44972 {
44973 PyThreadState* __tstate = wxPyBeginAllowThreads();
44974 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_Py_Void();
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44986 PyObject *resultobj = 0;
44987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44988 wxSize result;
44989 void *argp1 = 0 ;
44990 int res1 = 0 ;
44991 PyObject *swig_obj[1] ;
44992
44993 if (!args) SWIG_fail;
44994 swig_obj[0] = args;
44995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44996 if (!SWIG_IsOK(res1)) {
44997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44998 }
44999 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45000 {
45001 PyThreadState* __tstate = wxPyBeginAllowThreads();
45002 result = (arg1)->GetMinSize();
45003 wxPyEndAllowThreads(__tstate);
45004 if (PyErr_Occurred()) SWIG_fail;
45005 }
45006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45007 return resultobj;
45008 fail:
45009 return NULL;
45010 }
45011
45012
45013 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45014 PyObject *resultobj = 0;
45015 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45016 wxSize result;
45017 void *argp1 = 0 ;
45018 int res1 = 0 ;
45019 PyObject *swig_obj[1] ;
45020
45021 if (!args) SWIG_fail;
45022 swig_obj[0] = args;
45023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45024 if (!SWIG_IsOK(res1)) {
45025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45026 }
45027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45028 {
45029 PyThreadState* __tstate = wxPyBeginAllowThreads();
45030 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45031 wxPyEndAllowThreads(__tstate);
45032 if (PyErr_Occurred()) SWIG_fail;
45033 }
45034 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45035 return resultobj;
45036 fail:
45037 return NULL;
45038 }
45039
45040
45041 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45042 PyObject *resultobj = 0;
45043 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45044 int arg2 ;
45045 int arg3 ;
45046 void *argp1 = 0 ;
45047 int res1 = 0 ;
45048 int val2 ;
45049 int ecode2 = 0 ;
45050 int val3 ;
45051 int ecode3 = 0 ;
45052 PyObject * obj0 = 0 ;
45053 PyObject * obj1 = 0 ;
45054 PyObject * obj2 = 0 ;
45055 char * kwnames[] = {
45056 (char *) "self",(char *) "x",(char *) "y", NULL
45057 };
45058
45059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45061 if (!SWIG_IsOK(res1)) {
45062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45063 }
45064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45065 ecode2 = SWIG_AsVal_int(obj1, &val2);
45066 if (!SWIG_IsOK(ecode2)) {
45067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45068 }
45069 arg2 = static_cast< int >(val2);
45070 ecode3 = SWIG_AsVal_int(obj2, &val3);
45071 if (!SWIG_IsOK(ecode3)) {
45072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45073 }
45074 arg3 = static_cast< int >(val3);
45075 {
45076 PyThreadState* __tstate = wxPyBeginAllowThreads();
45077 (arg1)->SetInitSize(arg2,arg3);
45078 wxPyEndAllowThreads(__tstate);
45079 if (PyErr_Occurred()) SWIG_fail;
45080 }
45081 resultobj = SWIG_Py_Void();
45082 return resultobj;
45083 fail:
45084 return NULL;
45085 }
45086
45087
45088 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45089 PyObject *resultobj = 0;
45090 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45091 int arg2 ;
45092 int arg3 ;
45093 void *argp1 = 0 ;
45094 int res1 = 0 ;
45095 int val2 ;
45096 int ecode2 = 0 ;
45097 int val3 ;
45098 int ecode3 = 0 ;
45099 PyObject * obj0 = 0 ;
45100 PyObject * obj1 = 0 ;
45101 PyObject * obj2 = 0 ;
45102 char * kwnames[] = {
45103 (char *) "self",(char *) "width",(char *) "height", NULL
45104 };
45105
45106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45108 if (!SWIG_IsOK(res1)) {
45109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45110 }
45111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45112 ecode2 = SWIG_AsVal_int(obj1, &val2);
45113 if (!SWIG_IsOK(ecode2)) {
45114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45115 }
45116 arg2 = static_cast< int >(val2);
45117 ecode3 = SWIG_AsVal_int(obj2, &val3);
45118 if (!SWIG_IsOK(ecode3)) {
45119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45120 }
45121 arg3 = static_cast< int >(val3);
45122 {
45123 PyThreadState* __tstate = wxPyBeginAllowThreads();
45124 (arg1)->SetRatio(arg2,arg3);
45125 wxPyEndAllowThreads(__tstate);
45126 if (PyErr_Occurred()) SWIG_fail;
45127 }
45128 resultobj = SWIG_Py_Void();
45129 return resultobj;
45130 fail:
45131 return NULL;
45132 }
45133
45134
45135 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45136 PyObject *resultobj = 0;
45137 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45138 wxSize *arg2 = 0 ;
45139 void *argp1 = 0 ;
45140 int res1 = 0 ;
45141 wxSize temp2 ;
45142 PyObject * obj0 = 0 ;
45143 PyObject * obj1 = 0 ;
45144 char * kwnames[] = {
45145 (char *) "self",(char *) "size", NULL
45146 };
45147
45148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45150 if (!SWIG_IsOK(res1)) {
45151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45152 }
45153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45154 {
45155 arg2 = &temp2;
45156 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45157 }
45158 {
45159 PyThreadState* __tstate = wxPyBeginAllowThreads();
45160 (arg1)->SetRatio((wxSize const &)*arg2);
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_Py_Void();
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj = 0;
45173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45174 float arg2 ;
45175 void *argp1 = 0 ;
45176 int res1 = 0 ;
45177 float val2 ;
45178 int ecode2 = 0 ;
45179 PyObject * obj0 = 0 ;
45180 PyObject * obj1 = 0 ;
45181 char * kwnames[] = {
45182 (char *) "self",(char *) "ratio", NULL
45183 };
45184
45185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45187 if (!SWIG_IsOK(res1)) {
45188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45189 }
45190 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45191 ecode2 = SWIG_AsVal_float(obj1, &val2);
45192 if (!SWIG_IsOK(ecode2)) {
45193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45194 }
45195 arg2 = static_cast< float >(val2);
45196 {
45197 PyThreadState* __tstate = wxPyBeginAllowThreads();
45198 (arg1)->SetRatio(arg2);
45199 wxPyEndAllowThreads(__tstate);
45200 if (PyErr_Occurred()) SWIG_fail;
45201 }
45202 resultobj = SWIG_Py_Void();
45203 return resultobj;
45204 fail:
45205 return NULL;
45206 }
45207
45208
45209 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45210 PyObject *resultobj = 0;
45211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45212 float result;
45213 void *argp1 = 0 ;
45214 int res1 = 0 ;
45215 PyObject *swig_obj[1] ;
45216
45217 if (!args) SWIG_fail;
45218 swig_obj[0] = args;
45219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45220 if (!SWIG_IsOK(res1)) {
45221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45222 }
45223 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45224 {
45225 PyThreadState* __tstate = wxPyBeginAllowThreads();
45226 result = (float)(arg1)->GetRatio();
45227 wxPyEndAllowThreads(__tstate);
45228 if (PyErr_Occurred()) SWIG_fail;
45229 }
45230 resultobj = SWIG_From_float(static_cast< float >(result));
45231 return resultobj;
45232 fail:
45233 return NULL;
45234 }
45235
45236
45237 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45238 PyObject *resultobj = 0;
45239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45240 wxRect result;
45241 void *argp1 = 0 ;
45242 int res1 = 0 ;
45243 PyObject *swig_obj[1] ;
45244
45245 if (!args) SWIG_fail;
45246 swig_obj[0] = args;
45247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45248 if (!SWIG_IsOK(res1)) {
45249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45250 }
45251 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 result = (arg1)->GetRect();
45255 wxPyEndAllowThreads(__tstate);
45256 if (PyErr_Occurred()) SWIG_fail;
45257 }
45258 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45266 PyObject *resultobj = 0;
45267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45268 bool result;
45269 void *argp1 = 0 ;
45270 int res1 = 0 ;
45271 PyObject *swig_obj[1] ;
45272
45273 if (!args) SWIG_fail;
45274 swig_obj[0] = args;
45275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45276 if (!SWIG_IsOK(res1)) {
45277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45278 }
45279 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45280 {
45281 PyThreadState* __tstate = wxPyBeginAllowThreads();
45282 result = (bool)(arg1)->IsWindow();
45283 wxPyEndAllowThreads(__tstate);
45284 if (PyErr_Occurred()) SWIG_fail;
45285 }
45286 {
45287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45288 }
45289 return resultobj;
45290 fail:
45291 return NULL;
45292 }
45293
45294
45295 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45296 PyObject *resultobj = 0;
45297 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45298 bool result;
45299 void *argp1 = 0 ;
45300 int res1 = 0 ;
45301 PyObject *swig_obj[1] ;
45302
45303 if (!args) SWIG_fail;
45304 swig_obj[0] = args;
45305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45306 if (!SWIG_IsOK(res1)) {
45307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45308 }
45309 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45310 {
45311 PyThreadState* __tstate = wxPyBeginAllowThreads();
45312 result = (bool)(arg1)->IsSizer();
45313 wxPyEndAllowThreads(__tstate);
45314 if (PyErr_Occurred()) SWIG_fail;
45315 }
45316 {
45317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45318 }
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45326 PyObject *resultobj = 0;
45327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45328 bool result;
45329 void *argp1 = 0 ;
45330 int res1 = 0 ;
45331 PyObject *swig_obj[1] ;
45332
45333 if (!args) SWIG_fail;
45334 swig_obj[0] = args;
45335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45336 if (!SWIG_IsOK(res1)) {
45337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45338 }
45339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45340 {
45341 PyThreadState* __tstate = wxPyBeginAllowThreads();
45342 result = (bool)(arg1)->IsSpacer();
45343 wxPyEndAllowThreads(__tstate);
45344 if (PyErr_Occurred()) SWIG_fail;
45345 }
45346 {
45347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45348 }
45349 return resultobj;
45350 fail:
45351 return NULL;
45352 }
45353
45354
45355 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45356 PyObject *resultobj = 0;
45357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45358 int arg2 ;
45359 void *argp1 = 0 ;
45360 int res1 = 0 ;
45361 int val2 ;
45362 int ecode2 = 0 ;
45363 PyObject * obj0 = 0 ;
45364 PyObject * obj1 = 0 ;
45365 char * kwnames[] = {
45366 (char *) "self",(char *) "proportion", NULL
45367 };
45368
45369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45371 if (!SWIG_IsOK(res1)) {
45372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45373 }
45374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45375 ecode2 = SWIG_AsVal_int(obj1, &val2);
45376 if (!SWIG_IsOK(ecode2)) {
45377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45378 }
45379 arg2 = static_cast< int >(val2);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 (arg1)->SetProportion(arg2);
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 resultobj = SWIG_Py_Void();
45387 return resultobj;
45388 fail:
45389 return NULL;
45390 }
45391
45392
45393 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45394 PyObject *resultobj = 0;
45395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45396 int result;
45397 void *argp1 = 0 ;
45398 int res1 = 0 ;
45399 PyObject *swig_obj[1] ;
45400
45401 if (!args) SWIG_fail;
45402 swig_obj[0] = args;
45403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45406 }
45407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (int)(arg1)->GetProportion();
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_From_int(static_cast< int >(result));
45415 return resultobj;
45416 fail:
45417 return NULL;
45418 }
45419
45420
45421 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45422 PyObject *resultobj = 0;
45423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45424 int arg2 ;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 int val2 ;
45428 int ecode2 = 0 ;
45429 PyObject * obj0 = 0 ;
45430 PyObject * obj1 = 0 ;
45431 char * kwnames[] = {
45432 (char *) "self",(char *) "flag", NULL
45433 };
45434
45435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45437 if (!SWIG_IsOK(res1)) {
45438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45439 }
45440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45441 ecode2 = SWIG_AsVal_int(obj1, &val2);
45442 if (!SWIG_IsOK(ecode2)) {
45443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45444 }
45445 arg2 = static_cast< int >(val2);
45446 {
45447 PyThreadState* __tstate = wxPyBeginAllowThreads();
45448 (arg1)->SetFlag(arg2);
45449 wxPyEndAllowThreads(__tstate);
45450 if (PyErr_Occurred()) SWIG_fail;
45451 }
45452 resultobj = SWIG_Py_Void();
45453 return resultobj;
45454 fail:
45455 return NULL;
45456 }
45457
45458
45459 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45460 PyObject *resultobj = 0;
45461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45462 int result;
45463 void *argp1 = 0 ;
45464 int res1 = 0 ;
45465 PyObject *swig_obj[1] ;
45466
45467 if (!args) SWIG_fail;
45468 swig_obj[0] = args;
45469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45472 }
45473 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45474 {
45475 PyThreadState* __tstate = wxPyBeginAllowThreads();
45476 result = (int)(arg1)->GetFlag();
45477 wxPyEndAllowThreads(__tstate);
45478 if (PyErr_Occurred()) SWIG_fail;
45479 }
45480 resultobj = SWIG_From_int(static_cast< int >(result));
45481 return resultobj;
45482 fail:
45483 return NULL;
45484 }
45485
45486
45487 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45488 PyObject *resultobj = 0;
45489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45490 int arg2 ;
45491 void *argp1 = 0 ;
45492 int res1 = 0 ;
45493 int val2 ;
45494 int ecode2 = 0 ;
45495 PyObject * obj0 = 0 ;
45496 PyObject * obj1 = 0 ;
45497 char * kwnames[] = {
45498 (char *) "self",(char *) "border", NULL
45499 };
45500
45501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45503 if (!SWIG_IsOK(res1)) {
45504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45505 }
45506 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45507 ecode2 = SWIG_AsVal_int(obj1, &val2);
45508 if (!SWIG_IsOK(ecode2)) {
45509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45510 }
45511 arg2 = static_cast< int >(val2);
45512 {
45513 PyThreadState* __tstate = wxPyBeginAllowThreads();
45514 (arg1)->SetBorder(arg2);
45515 wxPyEndAllowThreads(__tstate);
45516 if (PyErr_Occurred()) SWIG_fail;
45517 }
45518 resultobj = SWIG_Py_Void();
45519 return resultobj;
45520 fail:
45521 return NULL;
45522 }
45523
45524
45525 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45526 PyObject *resultobj = 0;
45527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45528 int result;
45529 void *argp1 = 0 ;
45530 int res1 = 0 ;
45531 PyObject *swig_obj[1] ;
45532
45533 if (!args) SWIG_fail;
45534 swig_obj[0] = args;
45535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45538 }
45539 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 result = (int)(arg1)->GetBorder();
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_From_int(static_cast< int >(result));
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45554 PyObject *resultobj = 0;
45555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45556 wxWindow *result = 0 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 PyObject *swig_obj[1] ;
45560
45561 if (!args) SWIG_fail;
45562 swig_obj[0] = args;
45563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45566 }
45567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 result = (wxWindow *)(arg1)->GetWindow();
45571 wxPyEndAllowThreads(__tstate);
45572 if (PyErr_Occurred()) SWIG_fail;
45573 }
45574 {
45575 resultobj = wxPyMake_wxObject(result, 0);
45576 }
45577 return resultobj;
45578 fail:
45579 return NULL;
45580 }
45581
45582
45583 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45584 PyObject *resultobj = 0;
45585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45586 wxWindow *arg2 = (wxWindow *) 0 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 void *argp2 = 0 ;
45590 int res2 = 0 ;
45591 PyObject * obj0 = 0 ;
45592 PyObject * obj1 = 0 ;
45593 char * kwnames[] = {
45594 (char *) "self",(char *) "window", NULL
45595 };
45596
45597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45599 if (!SWIG_IsOK(res1)) {
45600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45601 }
45602 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45604 if (!SWIG_IsOK(res2)) {
45605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45606 }
45607 arg2 = reinterpret_cast< wxWindow * >(argp2);
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 (arg1)->SetWindow(arg2);
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 resultobj = SWIG_Py_Void();
45615 return resultobj;
45616 fail:
45617 return NULL;
45618 }
45619
45620
45621 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45622 PyObject *resultobj = 0;
45623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45624 wxSizer *result = 0 ;
45625 void *argp1 = 0 ;
45626 int res1 = 0 ;
45627 PyObject *swig_obj[1] ;
45628
45629 if (!args) SWIG_fail;
45630 swig_obj[0] = args;
45631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45634 }
45635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45636 {
45637 PyThreadState* __tstate = wxPyBeginAllowThreads();
45638 result = (wxSizer *)(arg1)->GetSizer();
45639 wxPyEndAllowThreads(__tstate);
45640 if (PyErr_Occurred()) SWIG_fail;
45641 }
45642 {
45643 resultobj = wxPyMake_wxObject(result, (bool)0);
45644 }
45645 return resultobj;
45646 fail:
45647 return NULL;
45648 }
45649
45650
45651 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45652 PyObject *resultobj = 0;
45653 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45654 wxSizer *arg2 = (wxSizer *) 0 ;
45655 void *argp1 = 0 ;
45656 int res1 = 0 ;
45657 int res2 = 0 ;
45658 PyObject * obj0 = 0 ;
45659 PyObject * obj1 = 0 ;
45660 char * kwnames[] = {
45661 (char *) "self",(char *) "sizer", NULL
45662 };
45663
45664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45666 if (!SWIG_IsOK(res1)) {
45667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45668 }
45669 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45670 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45671 if (!SWIG_IsOK(res2)) {
45672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45673 }
45674 {
45675 PyThreadState* __tstate = wxPyBeginAllowThreads();
45676 (arg1)->SetSizer(arg2);
45677 wxPyEndAllowThreads(__tstate);
45678 if (PyErr_Occurred()) SWIG_fail;
45679 }
45680 resultobj = SWIG_Py_Void();
45681 return resultobj;
45682 fail:
45683 return NULL;
45684 }
45685
45686
45687 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45688 PyObject *resultobj = 0;
45689 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45690 wxSize *result = 0 ;
45691 void *argp1 = 0 ;
45692 int res1 = 0 ;
45693 PyObject *swig_obj[1] ;
45694
45695 if (!args) SWIG_fail;
45696 swig_obj[0] = args;
45697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45700 }
45701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45702 {
45703 PyThreadState* __tstate = wxPyBeginAllowThreads();
45704 {
45705 wxSize const &_result_ref = (arg1)->GetSpacer();
45706 result = (wxSize *) &_result_ref;
45707 }
45708 wxPyEndAllowThreads(__tstate);
45709 if (PyErr_Occurred()) SWIG_fail;
45710 }
45711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45712 return resultobj;
45713 fail:
45714 return NULL;
45715 }
45716
45717
45718 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45719 PyObject *resultobj = 0;
45720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45721 wxSize *arg2 = 0 ;
45722 void *argp1 = 0 ;
45723 int res1 = 0 ;
45724 wxSize temp2 ;
45725 PyObject * obj0 = 0 ;
45726 PyObject * obj1 = 0 ;
45727 char * kwnames[] = {
45728 (char *) "self",(char *) "size", NULL
45729 };
45730
45731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45733 if (!SWIG_IsOK(res1)) {
45734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45735 }
45736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45737 {
45738 arg2 = &temp2;
45739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45740 }
45741 {
45742 PyThreadState* __tstate = wxPyBeginAllowThreads();
45743 (arg1)->SetSpacer((wxSize const &)*arg2);
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 resultobj = SWIG_Py_Void();
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45755 PyObject *resultobj = 0;
45756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45757 bool arg2 ;
45758 void *argp1 = 0 ;
45759 int res1 = 0 ;
45760 bool val2 ;
45761 int ecode2 = 0 ;
45762 PyObject * obj0 = 0 ;
45763 PyObject * obj1 = 0 ;
45764 char * kwnames[] = {
45765 (char *) "self",(char *) "show", NULL
45766 };
45767
45768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45770 if (!SWIG_IsOK(res1)) {
45771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45772 }
45773 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45774 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45775 if (!SWIG_IsOK(ecode2)) {
45776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45777 }
45778 arg2 = static_cast< bool >(val2);
45779 {
45780 PyThreadState* __tstate = wxPyBeginAllowThreads();
45781 (arg1)->Show(arg2);
45782 wxPyEndAllowThreads(__tstate);
45783 if (PyErr_Occurred()) SWIG_fail;
45784 }
45785 resultobj = SWIG_Py_Void();
45786 return resultobj;
45787 fail:
45788 return NULL;
45789 }
45790
45791
45792 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45793 PyObject *resultobj = 0;
45794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45795 bool result;
45796 void *argp1 = 0 ;
45797 int res1 = 0 ;
45798 PyObject *swig_obj[1] ;
45799
45800 if (!args) SWIG_fail;
45801 swig_obj[0] = args;
45802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45803 if (!SWIG_IsOK(res1)) {
45804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45805 }
45806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45807 {
45808 PyThreadState* __tstate = wxPyBeginAllowThreads();
45809 result = (bool)(arg1)->IsShown();
45810 wxPyEndAllowThreads(__tstate);
45811 if (PyErr_Occurred()) SWIG_fail;
45812 }
45813 {
45814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45815 }
45816 return resultobj;
45817 fail:
45818 return NULL;
45819 }
45820
45821
45822 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45823 PyObject *resultobj = 0;
45824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45825 wxPoint result;
45826 void *argp1 = 0 ;
45827 int res1 = 0 ;
45828 PyObject *swig_obj[1] ;
45829
45830 if (!args) SWIG_fail;
45831 swig_obj[0] = args;
45832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45833 if (!SWIG_IsOK(res1)) {
45834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45835 }
45836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45837 {
45838 PyThreadState* __tstate = wxPyBeginAllowThreads();
45839 result = (arg1)->GetPosition();
45840 wxPyEndAllowThreads(__tstate);
45841 if (PyErr_Occurred()) SWIG_fail;
45842 }
45843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45844 return resultobj;
45845 fail:
45846 return NULL;
45847 }
45848
45849
45850 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45851 PyObject *resultobj = 0;
45852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45853 PyObject *result = 0 ;
45854 void *argp1 = 0 ;
45855 int res1 = 0 ;
45856 PyObject *swig_obj[1] ;
45857
45858 if (!args) SWIG_fail;
45859 swig_obj[0] = args;
45860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45861 if (!SWIG_IsOK(res1)) {
45862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45863 }
45864 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45865 {
45866 PyThreadState* __tstate = wxPyBeginAllowThreads();
45867 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45868 wxPyEndAllowThreads(__tstate);
45869 if (PyErr_Occurred()) SWIG_fail;
45870 }
45871 resultobj = result;
45872 return resultobj;
45873 fail:
45874 return NULL;
45875 }
45876
45877
45878 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45879 PyObject *resultobj = 0;
45880 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45881 PyObject *arg2 = (PyObject *) 0 ;
45882 void *argp1 = 0 ;
45883 int res1 = 0 ;
45884 PyObject * obj0 = 0 ;
45885 PyObject * obj1 = 0 ;
45886 char * kwnames[] = {
45887 (char *) "self",(char *) "userData", NULL
45888 };
45889
45890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45892 if (!SWIG_IsOK(res1)) {
45893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45894 }
45895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45896 arg2 = obj1;
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 wxSizerItem_SetUserData(arg1,arg2);
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_Py_Void();
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45911 PyObject *obj;
45912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45913 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45914 return SWIG_Py_Void();
45915 }
45916
45917 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45918 return SWIG_Python_InitShadowInstance(args);
45919 }
45920
45921 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45922 PyObject *resultobj = 0;
45923 wxSizer *arg1 = (wxSizer *) 0 ;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 PyObject *swig_obj[1] ;
45927
45928 if (!args) SWIG_fail;
45929 swig_obj[0] = args;
45930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45931 if (!SWIG_IsOK(res1)) {
45932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45933 }
45934 arg1 = reinterpret_cast< wxSizer * >(argp1);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 delete arg1;
45938
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 resultobj = SWIG_Py_Void();
45943 return resultobj;
45944 fail:
45945 return NULL;
45946 }
45947
45948
45949 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45950 PyObject *resultobj = 0;
45951 wxSizer *arg1 = (wxSizer *) 0 ;
45952 PyObject *arg2 = (PyObject *) 0 ;
45953 void *argp1 = 0 ;
45954 int res1 = 0 ;
45955 PyObject * obj0 = 0 ;
45956 PyObject * obj1 = 0 ;
45957 char * kwnames[] = {
45958 (char *) "self",(char *) "_self", NULL
45959 };
45960
45961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45963 if (!SWIG_IsOK(res1)) {
45964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45965 }
45966 arg1 = reinterpret_cast< wxSizer * >(argp1);
45967 arg2 = obj1;
45968 {
45969 PyThreadState* __tstate = wxPyBeginAllowThreads();
45970 wxSizer__setOORInfo(arg1,arg2);
45971 wxPyEndAllowThreads(__tstate);
45972 if (PyErr_Occurred()) SWIG_fail;
45973 }
45974 resultobj = SWIG_Py_Void();
45975 return resultobj;
45976 fail:
45977 return NULL;
45978 }
45979
45980
45981 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45982 PyObject *resultobj = 0;
45983 wxSizer *arg1 = (wxSizer *) 0 ;
45984 PyObject *arg2 = (PyObject *) 0 ;
45985 int arg3 = (int) 0 ;
45986 int arg4 = (int) 0 ;
45987 int arg5 = (int) 0 ;
45988 PyObject *arg6 = (PyObject *) NULL ;
45989 wxSizerItem *result = 0 ;
45990 void *argp1 = 0 ;
45991 int res1 = 0 ;
45992 int val3 ;
45993 int ecode3 = 0 ;
45994 int val4 ;
45995 int ecode4 = 0 ;
45996 int val5 ;
45997 int ecode5 = 0 ;
45998 PyObject * obj0 = 0 ;
45999 PyObject * obj1 = 0 ;
46000 PyObject * obj2 = 0 ;
46001 PyObject * obj3 = 0 ;
46002 PyObject * obj4 = 0 ;
46003 PyObject * obj5 = 0 ;
46004 char * kwnames[] = {
46005 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46006 };
46007
46008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46010 if (!SWIG_IsOK(res1)) {
46011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46012 }
46013 arg1 = reinterpret_cast< wxSizer * >(argp1);
46014 arg2 = obj1;
46015 if (obj2) {
46016 ecode3 = SWIG_AsVal_int(obj2, &val3);
46017 if (!SWIG_IsOK(ecode3)) {
46018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46019 }
46020 arg3 = static_cast< int >(val3);
46021 }
46022 if (obj3) {
46023 ecode4 = SWIG_AsVal_int(obj3, &val4);
46024 if (!SWIG_IsOK(ecode4)) {
46025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46026 }
46027 arg4 = static_cast< int >(val4);
46028 }
46029 if (obj4) {
46030 ecode5 = SWIG_AsVal_int(obj4, &val5);
46031 if (!SWIG_IsOK(ecode5)) {
46032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46033 }
46034 arg5 = static_cast< int >(val5);
46035 }
46036 if (obj5) {
46037 arg6 = obj5;
46038 }
46039 {
46040 PyThreadState* __tstate = wxPyBeginAllowThreads();
46041 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46042 wxPyEndAllowThreads(__tstate);
46043 if (PyErr_Occurred()) SWIG_fail;
46044 }
46045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46046 return resultobj;
46047 fail:
46048 return NULL;
46049 }
46050
46051
46052 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46053 PyObject *resultobj = 0;
46054 wxSizer *arg1 = (wxSizer *) 0 ;
46055 int arg2 ;
46056 PyObject *arg3 = (PyObject *) 0 ;
46057 int arg4 = (int) 0 ;
46058 int arg5 = (int) 0 ;
46059 int arg6 = (int) 0 ;
46060 PyObject *arg7 = (PyObject *) NULL ;
46061 wxSizerItem *result = 0 ;
46062 void *argp1 = 0 ;
46063 int res1 = 0 ;
46064 int val2 ;
46065 int ecode2 = 0 ;
46066 int val4 ;
46067 int ecode4 = 0 ;
46068 int val5 ;
46069 int ecode5 = 0 ;
46070 int val6 ;
46071 int ecode6 = 0 ;
46072 PyObject * obj0 = 0 ;
46073 PyObject * obj1 = 0 ;
46074 PyObject * obj2 = 0 ;
46075 PyObject * obj3 = 0 ;
46076 PyObject * obj4 = 0 ;
46077 PyObject * obj5 = 0 ;
46078 PyObject * obj6 = 0 ;
46079 char * kwnames[] = {
46080 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46081 };
46082
46083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46085 if (!SWIG_IsOK(res1)) {
46086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46087 }
46088 arg1 = reinterpret_cast< wxSizer * >(argp1);
46089 ecode2 = SWIG_AsVal_int(obj1, &val2);
46090 if (!SWIG_IsOK(ecode2)) {
46091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46092 }
46093 arg2 = static_cast< int >(val2);
46094 arg3 = obj2;
46095 if (obj3) {
46096 ecode4 = SWIG_AsVal_int(obj3, &val4);
46097 if (!SWIG_IsOK(ecode4)) {
46098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46099 }
46100 arg4 = static_cast< int >(val4);
46101 }
46102 if (obj4) {
46103 ecode5 = SWIG_AsVal_int(obj4, &val5);
46104 if (!SWIG_IsOK(ecode5)) {
46105 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46106 }
46107 arg5 = static_cast< int >(val5);
46108 }
46109 if (obj5) {
46110 ecode6 = SWIG_AsVal_int(obj5, &val6);
46111 if (!SWIG_IsOK(ecode6)) {
46112 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46113 }
46114 arg6 = static_cast< int >(val6);
46115 }
46116 if (obj6) {
46117 arg7 = obj6;
46118 }
46119 {
46120 PyThreadState* __tstate = wxPyBeginAllowThreads();
46121 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46122 wxPyEndAllowThreads(__tstate);
46123 if (PyErr_Occurred()) SWIG_fail;
46124 }
46125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46126 return resultobj;
46127 fail:
46128 return NULL;
46129 }
46130
46131
46132 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46133 PyObject *resultobj = 0;
46134 wxSizer *arg1 = (wxSizer *) 0 ;
46135 PyObject *arg2 = (PyObject *) 0 ;
46136 int arg3 = (int) 0 ;
46137 int arg4 = (int) 0 ;
46138 int arg5 = (int) 0 ;
46139 PyObject *arg6 = (PyObject *) NULL ;
46140 wxSizerItem *result = 0 ;
46141 void *argp1 = 0 ;
46142 int res1 = 0 ;
46143 int val3 ;
46144 int ecode3 = 0 ;
46145 int val4 ;
46146 int ecode4 = 0 ;
46147 int val5 ;
46148 int ecode5 = 0 ;
46149 PyObject * obj0 = 0 ;
46150 PyObject * obj1 = 0 ;
46151 PyObject * obj2 = 0 ;
46152 PyObject * obj3 = 0 ;
46153 PyObject * obj4 = 0 ;
46154 PyObject * obj5 = 0 ;
46155 char * kwnames[] = {
46156 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46157 };
46158
46159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46163 }
46164 arg1 = reinterpret_cast< wxSizer * >(argp1);
46165 arg2 = obj1;
46166 if (obj2) {
46167 ecode3 = SWIG_AsVal_int(obj2, &val3);
46168 if (!SWIG_IsOK(ecode3)) {
46169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46170 }
46171 arg3 = static_cast< int >(val3);
46172 }
46173 if (obj3) {
46174 ecode4 = SWIG_AsVal_int(obj3, &val4);
46175 if (!SWIG_IsOK(ecode4)) {
46176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46177 }
46178 arg4 = static_cast< int >(val4);
46179 }
46180 if (obj4) {
46181 ecode5 = SWIG_AsVal_int(obj4, &val5);
46182 if (!SWIG_IsOK(ecode5)) {
46183 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46184 }
46185 arg5 = static_cast< int >(val5);
46186 }
46187 if (obj5) {
46188 arg6 = obj5;
46189 }
46190 {
46191 PyThreadState* __tstate = wxPyBeginAllowThreads();
46192 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46193 wxPyEndAllowThreads(__tstate);
46194 if (PyErr_Occurred()) SWIG_fail;
46195 }
46196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46197 return resultobj;
46198 fail:
46199 return NULL;
46200 }
46201
46202
46203 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46204 PyObject *resultobj = 0;
46205 wxSizer *arg1 = (wxSizer *) 0 ;
46206 PyObject *arg2 = (PyObject *) 0 ;
46207 bool result;
46208 void *argp1 = 0 ;
46209 int res1 = 0 ;
46210 PyObject * obj0 = 0 ;
46211 PyObject * obj1 = 0 ;
46212 char * kwnames[] = {
46213 (char *) "self",(char *) "item", NULL
46214 };
46215
46216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46218 if (!SWIG_IsOK(res1)) {
46219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46220 }
46221 arg1 = reinterpret_cast< wxSizer * >(argp1);
46222 arg2 = obj1;
46223 {
46224 PyThreadState* __tstate = wxPyBeginAllowThreads();
46225 result = (bool)wxSizer_Remove(arg1,arg2);
46226 wxPyEndAllowThreads(__tstate);
46227 if (PyErr_Occurred()) SWIG_fail;
46228 }
46229 {
46230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46231 }
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxSizer *arg1 = (wxSizer *) 0 ;
46241 PyObject *arg2 = (PyObject *) 0 ;
46242 bool result;
46243 void *argp1 = 0 ;
46244 int res1 = 0 ;
46245 PyObject * obj0 = 0 ;
46246 PyObject * obj1 = 0 ;
46247 char * kwnames[] = {
46248 (char *) "self",(char *) "item", NULL
46249 };
46250
46251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46253 if (!SWIG_IsOK(res1)) {
46254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46255 }
46256 arg1 = reinterpret_cast< wxSizer * >(argp1);
46257 arg2 = obj1;
46258 {
46259 PyThreadState* __tstate = wxPyBeginAllowThreads();
46260 result = (bool)wxSizer_Detach(arg1,arg2);
46261 wxPyEndAllowThreads(__tstate);
46262 if (PyErr_Occurred()) SWIG_fail;
46263 }
46264 {
46265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46266 }
46267 return resultobj;
46268 fail:
46269 return NULL;
46270 }
46271
46272
46273 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46274 PyObject *resultobj = 0;
46275 wxSizer *arg1 = (wxSizer *) 0 ;
46276 PyObject *arg2 = (PyObject *) 0 ;
46277 wxSizerItem *result = 0 ;
46278 void *argp1 = 0 ;
46279 int res1 = 0 ;
46280 PyObject * obj0 = 0 ;
46281 PyObject * obj1 = 0 ;
46282 char * kwnames[] = {
46283 (char *) "self",(char *) "item", NULL
46284 };
46285
46286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46290 }
46291 arg1 = reinterpret_cast< wxSizer * >(argp1);
46292 arg2 = obj1;
46293 {
46294 PyThreadState* __tstate = wxPyBeginAllowThreads();
46295 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46296 wxPyEndAllowThreads(__tstate);
46297 if (PyErr_Occurred()) SWIG_fail;
46298 }
46299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46300 return resultobj;
46301 fail:
46302 return NULL;
46303 }
46304
46305
46306 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46307 PyObject *resultobj = 0;
46308 wxSizer *arg1 = (wxSizer *) 0 ;
46309 PyObject *arg2 = (PyObject *) 0 ;
46310 wxSize *arg3 = 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 wxSize temp3 ;
46314 PyObject * obj0 = 0 ;
46315 PyObject * obj1 = 0 ;
46316 PyObject * obj2 = 0 ;
46317 char * kwnames[] = {
46318 (char *) "self",(char *) "item",(char *) "size", NULL
46319 };
46320
46321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46323 if (!SWIG_IsOK(res1)) {
46324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46325 }
46326 arg1 = reinterpret_cast< wxSizer * >(argp1);
46327 arg2 = obj1;
46328 {
46329 arg3 = &temp3;
46330 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46331 }
46332 {
46333 PyThreadState* __tstate = wxPyBeginAllowThreads();
46334 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46335 wxPyEndAllowThreads(__tstate);
46336 if (PyErr_Occurred()) SWIG_fail;
46337 }
46338 resultobj = SWIG_Py_Void();
46339 return resultobj;
46340 fail:
46341 return NULL;
46342 }
46343
46344
46345 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46346 PyObject *resultobj = 0;
46347 wxSizer *arg1 = (wxSizer *) 0 ;
46348 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46349 wxSizerItem *result = 0 ;
46350 void *argp1 = 0 ;
46351 int res1 = 0 ;
46352 int res2 = 0 ;
46353 PyObject * obj0 = 0 ;
46354 PyObject * obj1 = 0 ;
46355 char * kwnames[] = {
46356 (char *) "self",(char *) "item", NULL
46357 };
46358
46359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46361 if (!SWIG_IsOK(res1)) {
46362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46363 }
46364 arg1 = reinterpret_cast< wxSizer * >(argp1);
46365 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46366 if (!SWIG_IsOK(res2)) {
46367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46368 }
46369 {
46370 PyThreadState* __tstate = wxPyBeginAllowThreads();
46371 result = (wxSizerItem *)(arg1)->Add(arg2);
46372 wxPyEndAllowThreads(__tstate);
46373 if (PyErr_Occurred()) SWIG_fail;
46374 }
46375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46376 return resultobj;
46377 fail:
46378 return NULL;
46379 }
46380
46381
46382 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46383 PyObject *resultobj = 0;
46384 wxSizer *arg1 = (wxSizer *) 0 ;
46385 size_t arg2 ;
46386 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46387 wxSizerItem *result = 0 ;
46388 void *argp1 = 0 ;
46389 int res1 = 0 ;
46390 size_t val2 ;
46391 int ecode2 = 0 ;
46392 int res3 = 0 ;
46393 PyObject * obj0 = 0 ;
46394 PyObject * obj1 = 0 ;
46395 PyObject * obj2 = 0 ;
46396 char * kwnames[] = {
46397 (char *) "self",(char *) "index",(char *) "item", NULL
46398 };
46399
46400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46402 if (!SWIG_IsOK(res1)) {
46403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46404 }
46405 arg1 = reinterpret_cast< wxSizer * >(argp1);
46406 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46407 if (!SWIG_IsOK(ecode2)) {
46408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46409 }
46410 arg2 = static_cast< size_t >(val2);
46411 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46412 if (!SWIG_IsOK(res3)) {
46413 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46414 }
46415 {
46416 PyThreadState* __tstate = wxPyBeginAllowThreads();
46417 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46418 wxPyEndAllowThreads(__tstate);
46419 if (PyErr_Occurred()) SWIG_fail;
46420 }
46421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46422 return resultobj;
46423 fail:
46424 return NULL;
46425 }
46426
46427
46428 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46429 PyObject *resultobj = 0;
46430 wxSizer *arg1 = (wxSizer *) 0 ;
46431 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46432 wxSizerItem *result = 0 ;
46433 void *argp1 = 0 ;
46434 int res1 = 0 ;
46435 int res2 = 0 ;
46436 PyObject * obj0 = 0 ;
46437 PyObject * obj1 = 0 ;
46438 char * kwnames[] = {
46439 (char *) "self",(char *) "item", NULL
46440 };
46441
46442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46444 if (!SWIG_IsOK(res1)) {
46445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46446 }
46447 arg1 = reinterpret_cast< wxSizer * >(argp1);
46448 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46449 if (!SWIG_IsOK(res2)) {
46450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46451 }
46452 {
46453 PyThreadState* __tstate = wxPyBeginAllowThreads();
46454 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46455 wxPyEndAllowThreads(__tstate);
46456 if (PyErr_Occurred()) SWIG_fail;
46457 }
46458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46459 return resultobj;
46460 fail:
46461 return NULL;
46462 }
46463
46464
46465 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46466 PyObject *resultobj = 0;
46467 wxSizer *arg1 = (wxSizer *) 0 ;
46468 int arg2 ;
46469 int arg3 ;
46470 int arg4 ;
46471 int arg5 ;
46472 void *argp1 = 0 ;
46473 int res1 = 0 ;
46474 int val2 ;
46475 int ecode2 = 0 ;
46476 int val3 ;
46477 int ecode3 = 0 ;
46478 int val4 ;
46479 int ecode4 = 0 ;
46480 int val5 ;
46481 int ecode5 = 0 ;
46482 PyObject * obj0 = 0 ;
46483 PyObject * obj1 = 0 ;
46484 PyObject * obj2 = 0 ;
46485 PyObject * obj3 = 0 ;
46486 PyObject * obj4 = 0 ;
46487 char * kwnames[] = {
46488 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46489 };
46490
46491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizer * >(argp1);
46497 ecode2 = SWIG_AsVal_int(obj1, &val2);
46498 if (!SWIG_IsOK(ecode2)) {
46499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46500 }
46501 arg2 = static_cast< int >(val2);
46502 ecode3 = SWIG_AsVal_int(obj2, &val3);
46503 if (!SWIG_IsOK(ecode3)) {
46504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46505 }
46506 arg3 = static_cast< int >(val3);
46507 ecode4 = SWIG_AsVal_int(obj3, &val4);
46508 if (!SWIG_IsOK(ecode4)) {
46509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46510 }
46511 arg4 = static_cast< int >(val4);
46512 ecode5 = SWIG_AsVal_int(obj4, &val5);
46513 if (!SWIG_IsOK(ecode5)) {
46514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46515 }
46516 arg5 = static_cast< int >(val5);
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_Py_Void();
46524 return resultobj;
46525 fail:
46526 return NULL;
46527 }
46528
46529
46530 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46531 PyObject *resultobj = 0;
46532 wxSizer *arg1 = (wxSizer *) 0 ;
46533 wxSize *arg2 = 0 ;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 wxSize temp2 ;
46537 PyObject * obj0 = 0 ;
46538 PyObject * obj1 = 0 ;
46539 char * kwnames[] = {
46540 (char *) "self",(char *) "size", NULL
46541 };
46542
46543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46545 if (!SWIG_IsOK(res1)) {
46546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46547 }
46548 arg1 = reinterpret_cast< wxSizer * >(argp1);
46549 {
46550 arg2 = &temp2;
46551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46552 }
46553 {
46554 PyThreadState* __tstate = wxPyBeginAllowThreads();
46555 (arg1)->SetMinSize((wxSize const &)*arg2);
46556 wxPyEndAllowThreads(__tstate);
46557 if (PyErr_Occurred()) SWIG_fail;
46558 }
46559 resultobj = SWIG_Py_Void();
46560 return resultobj;
46561 fail:
46562 return NULL;
46563 }
46564
46565
46566 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46567 PyObject *resultobj = 0;
46568 wxSizer *arg1 = (wxSizer *) 0 ;
46569 wxSize result;
46570 void *argp1 = 0 ;
46571 int res1 = 0 ;
46572 PyObject *swig_obj[1] ;
46573
46574 if (!args) SWIG_fail;
46575 swig_obj[0] = args;
46576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46577 if (!SWIG_IsOK(res1)) {
46578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46579 }
46580 arg1 = reinterpret_cast< wxSizer * >(argp1);
46581 {
46582 PyThreadState* __tstate = wxPyBeginAllowThreads();
46583 result = (arg1)->GetSize();
46584 wxPyEndAllowThreads(__tstate);
46585 if (PyErr_Occurred()) SWIG_fail;
46586 }
46587 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46588 return resultobj;
46589 fail:
46590 return NULL;
46591 }
46592
46593
46594 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46595 PyObject *resultobj = 0;
46596 wxSizer *arg1 = (wxSizer *) 0 ;
46597 wxPoint result;
46598 void *argp1 = 0 ;
46599 int res1 = 0 ;
46600 PyObject *swig_obj[1] ;
46601
46602 if (!args) SWIG_fail;
46603 swig_obj[0] = args;
46604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46605 if (!SWIG_IsOK(res1)) {
46606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46607 }
46608 arg1 = reinterpret_cast< wxSizer * >(argp1);
46609 {
46610 PyThreadState* __tstate = wxPyBeginAllowThreads();
46611 result = (arg1)->GetPosition();
46612 wxPyEndAllowThreads(__tstate);
46613 if (PyErr_Occurred()) SWIG_fail;
46614 }
46615 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46616 return resultobj;
46617 fail:
46618 return NULL;
46619 }
46620
46621
46622 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46623 PyObject *resultobj = 0;
46624 wxSizer *arg1 = (wxSizer *) 0 ;
46625 wxSize result;
46626 void *argp1 = 0 ;
46627 int res1 = 0 ;
46628 PyObject *swig_obj[1] ;
46629
46630 if (!args) SWIG_fail;
46631 swig_obj[0] = args;
46632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46633 if (!SWIG_IsOK(res1)) {
46634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46635 }
46636 arg1 = reinterpret_cast< wxSizer * >(argp1);
46637 {
46638 PyThreadState* __tstate = wxPyBeginAllowThreads();
46639 result = (arg1)->GetMinSize();
46640 wxPyEndAllowThreads(__tstate);
46641 if (PyErr_Occurred()) SWIG_fail;
46642 }
46643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46644 return resultobj;
46645 fail:
46646 return NULL;
46647 }
46648
46649
46650 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46651 PyObject *resultobj = 0;
46652 wxSizer *arg1 = (wxSizer *) 0 ;
46653 void *argp1 = 0 ;
46654 int res1 = 0 ;
46655 PyObject *swig_obj[1] ;
46656
46657 if (!args) SWIG_fail;
46658 swig_obj[0] = args;
46659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46660 if (!SWIG_IsOK(res1)) {
46661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46662 }
46663 arg1 = reinterpret_cast< wxSizer * >(argp1);
46664 {
46665 PyThreadState* __tstate = wxPyBeginAllowThreads();
46666 (arg1)->RecalcSizes();
46667 wxPyEndAllowThreads(__tstate);
46668 if (PyErr_Occurred()) SWIG_fail;
46669 }
46670 resultobj = SWIG_Py_Void();
46671 return resultobj;
46672 fail:
46673 return NULL;
46674 }
46675
46676
46677 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46678 PyObject *resultobj = 0;
46679 wxSizer *arg1 = (wxSizer *) 0 ;
46680 wxSize result;
46681 void *argp1 = 0 ;
46682 int res1 = 0 ;
46683 PyObject *swig_obj[1] ;
46684
46685 if (!args) SWIG_fail;
46686 swig_obj[0] = args;
46687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46688 if (!SWIG_IsOK(res1)) {
46689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46690 }
46691 arg1 = reinterpret_cast< wxSizer * >(argp1);
46692 {
46693 PyThreadState* __tstate = wxPyBeginAllowThreads();
46694 result = (arg1)->CalcMin();
46695 wxPyEndAllowThreads(__tstate);
46696 if (PyErr_Occurred()) SWIG_fail;
46697 }
46698 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46699 return resultobj;
46700 fail:
46701 return NULL;
46702 }
46703
46704
46705 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46706 PyObject *resultobj = 0;
46707 wxSizer *arg1 = (wxSizer *) 0 ;
46708 void *argp1 = 0 ;
46709 int res1 = 0 ;
46710 PyObject *swig_obj[1] ;
46711
46712 if (!args) SWIG_fail;
46713 swig_obj[0] = args;
46714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46715 if (!SWIG_IsOK(res1)) {
46716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46717 }
46718 arg1 = reinterpret_cast< wxSizer * >(argp1);
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 (arg1)->Layout();
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_Py_Void();
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxSizer *arg1 = (wxSizer *) 0 ;
46735 wxWindow *arg2 = (wxWindow *) 0 ;
46736 wxSize result;
46737 void *argp1 = 0 ;
46738 int res1 = 0 ;
46739 void *argp2 = 0 ;
46740 int res2 = 0 ;
46741 PyObject * obj0 = 0 ;
46742 PyObject * obj1 = 0 ;
46743 char * kwnames[] = {
46744 (char *) "self",(char *) "window", NULL
46745 };
46746
46747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46749 if (!SWIG_IsOK(res1)) {
46750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46751 }
46752 arg1 = reinterpret_cast< wxSizer * >(argp1);
46753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46754 if (!SWIG_IsOK(res2)) {
46755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46756 }
46757 arg2 = reinterpret_cast< wxWindow * >(argp2);
46758 {
46759 PyThreadState* __tstate = wxPyBeginAllowThreads();
46760 result = (arg1)->Fit(arg2);
46761 wxPyEndAllowThreads(__tstate);
46762 if (PyErr_Occurred()) SWIG_fail;
46763 }
46764 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46765 return resultobj;
46766 fail:
46767 return NULL;
46768 }
46769
46770
46771 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46772 PyObject *resultobj = 0;
46773 wxSizer *arg1 = (wxSizer *) 0 ;
46774 wxWindow *arg2 = (wxWindow *) 0 ;
46775 void *argp1 = 0 ;
46776 int res1 = 0 ;
46777 void *argp2 = 0 ;
46778 int res2 = 0 ;
46779 PyObject * obj0 = 0 ;
46780 PyObject * obj1 = 0 ;
46781 char * kwnames[] = {
46782 (char *) "self",(char *) "window", NULL
46783 };
46784
46785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46789 }
46790 arg1 = reinterpret_cast< wxSizer * >(argp1);
46791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46792 if (!SWIG_IsOK(res2)) {
46793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46794 }
46795 arg2 = reinterpret_cast< wxWindow * >(argp2);
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 (arg1)->FitInside(arg2);
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_Py_Void();
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46810 PyObject *resultobj = 0;
46811 wxSizer *arg1 = (wxSizer *) 0 ;
46812 wxWindow *arg2 = (wxWindow *) 0 ;
46813 void *argp1 = 0 ;
46814 int res1 = 0 ;
46815 void *argp2 = 0 ;
46816 int res2 = 0 ;
46817 PyObject * obj0 = 0 ;
46818 PyObject * obj1 = 0 ;
46819 char * kwnames[] = {
46820 (char *) "self",(char *) "window", NULL
46821 };
46822
46823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46827 }
46828 arg1 = reinterpret_cast< wxSizer * >(argp1);
46829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46830 if (!SWIG_IsOK(res2)) {
46831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46832 }
46833 arg2 = reinterpret_cast< wxWindow * >(argp2);
46834 {
46835 PyThreadState* __tstate = wxPyBeginAllowThreads();
46836 (arg1)->SetSizeHints(arg2);
46837 wxPyEndAllowThreads(__tstate);
46838 if (PyErr_Occurred()) SWIG_fail;
46839 }
46840 resultobj = SWIG_Py_Void();
46841 return resultobj;
46842 fail:
46843 return NULL;
46844 }
46845
46846
46847 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46848 PyObject *resultobj = 0;
46849 wxSizer *arg1 = (wxSizer *) 0 ;
46850 wxWindow *arg2 = (wxWindow *) 0 ;
46851 void *argp1 = 0 ;
46852 int res1 = 0 ;
46853 void *argp2 = 0 ;
46854 int res2 = 0 ;
46855 PyObject * obj0 = 0 ;
46856 PyObject * obj1 = 0 ;
46857 char * kwnames[] = {
46858 (char *) "self",(char *) "window", NULL
46859 };
46860
46861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46863 if (!SWIG_IsOK(res1)) {
46864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46865 }
46866 arg1 = reinterpret_cast< wxSizer * >(argp1);
46867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46868 if (!SWIG_IsOK(res2)) {
46869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46870 }
46871 arg2 = reinterpret_cast< wxWindow * >(argp2);
46872 {
46873 PyThreadState* __tstate = wxPyBeginAllowThreads();
46874 (arg1)->SetVirtualSizeHints(arg2);
46875 wxPyEndAllowThreads(__tstate);
46876 if (PyErr_Occurred()) SWIG_fail;
46877 }
46878 resultobj = SWIG_Py_Void();
46879 return resultobj;
46880 fail:
46881 return NULL;
46882 }
46883
46884
46885 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46886 PyObject *resultobj = 0;
46887 wxSizer *arg1 = (wxSizer *) 0 ;
46888 bool arg2 = (bool) false ;
46889 void *argp1 = 0 ;
46890 int res1 = 0 ;
46891 bool val2 ;
46892 int ecode2 = 0 ;
46893 PyObject * obj0 = 0 ;
46894 PyObject * obj1 = 0 ;
46895 char * kwnames[] = {
46896 (char *) "self",(char *) "deleteWindows", NULL
46897 };
46898
46899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46901 if (!SWIG_IsOK(res1)) {
46902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46903 }
46904 arg1 = reinterpret_cast< wxSizer * >(argp1);
46905 if (obj1) {
46906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46907 if (!SWIG_IsOK(ecode2)) {
46908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46909 }
46910 arg2 = static_cast< bool >(val2);
46911 }
46912 {
46913 PyThreadState* __tstate = wxPyBeginAllowThreads();
46914 (arg1)->Clear(arg2);
46915 wxPyEndAllowThreads(__tstate);
46916 if (PyErr_Occurred()) SWIG_fail;
46917 }
46918 resultobj = SWIG_Py_Void();
46919 return resultobj;
46920 fail:
46921 return NULL;
46922 }
46923
46924
46925 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46926 PyObject *resultobj = 0;
46927 wxSizer *arg1 = (wxSizer *) 0 ;
46928 void *argp1 = 0 ;
46929 int res1 = 0 ;
46930 PyObject *swig_obj[1] ;
46931
46932 if (!args) SWIG_fail;
46933 swig_obj[0] = args;
46934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46935 if (!SWIG_IsOK(res1)) {
46936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46937 }
46938 arg1 = reinterpret_cast< wxSizer * >(argp1);
46939 {
46940 PyThreadState* __tstate = wxPyBeginAllowThreads();
46941 (arg1)->DeleteWindows();
46942 wxPyEndAllowThreads(__tstate);
46943 if (PyErr_Occurred()) SWIG_fail;
46944 }
46945 resultobj = SWIG_Py_Void();
46946 return resultobj;
46947 fail:
46948 return NULL;
46949 }
46950
46951
46952 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46953 PyObject *resultobj = 0;
46954 wxSizer *arg1 = (wxSizer *) 0 ;
46955 PyObject *result = 0 ;
46956 void *argp1 = 0 ;
46957 int res1 = 0 ;
46958 PyObject *swig_obj[1] ;
46959
46960 if (!args) SWIG_fail;
46961 swig_obj[0] = args;
46962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46963 if (!SWIG_IsOK(res1)) {
46964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46965 }
46966 arg1 = reinterpret_cast< wxSizer * >(argp1);
46967 {
46968 PyThreadState* __tstate = wxPyBeginAllowThreads();
46969 result = (PyObject *)wxSizer_GetChildren(arg1);
46970 wxPyEndAllowThreads(__tstate);
46971 if (PyErr_Occurred()) SWIG_fail;
46972 }
46973 resultobj = result;
46974 return resultobj;
46975 fail:
46976 return NULL;
46977 }
46978
46979
46980 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46981 PyObject *resultobj = 0;
46982 wxSizer *arg1 = (wxSizer *) 0 ;
46983 PyObject *arg2 = (PyObject *) 0 ;
46984 bool arg3 = (bool) true ;
46985 bool arg4 = (bool) false ;
46986 bool result;
46987 void *argp1 = 0 ;
46988 int res1 = 0 ;
46989 bool val3 ;
46990 int ecode3 = 0 ;
46991 bool val4 ;
46992 int ecode4 = 0 ;
46993 PyObject * obj0 = 0 ;
46994 PyObject * obj1 = 0 ;
46995 PyObject * obj2 = 0 ;
46996 PyObject * obj3 = 0 ;
46997 char * kwnames[] = {
46998 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46999 };
47000
47001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizer * >(argp1);
47007 arg2 = obj1;
47008 if (obj2) {
47009 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47010 if (!SWIG_IsOK(ecode3)) {
47011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47012 }
47013 arg3 = static_cast< bool >(val3);
47014 }
47015 if (obj3) {
47016 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47017 if (!SWIG_IsOK(ecode4)) {
47018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47019 }
47020 arg4 = static_cast< bool >(val4);
47021 }
47022 {
47023 PyThreadState* __tstate = wxPyBeginAllowThreads();
47024 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47025 wxPyEndAllowThreads(__tstate);
47026 if (PyErr_Occurred()) SWIG_fail;
47027 }
47028 {
47029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47030 }
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47038 PyObject *resultobj = 0;
47039 wxSizer *arg1 = (wxSizer *) 0 ;
47040 PyObject *arg2 = (PyObject *) 0 ;
47041 bool result;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 PyObject * obj0 = 0 ;
47045 PyObject * obj1 = 0 ;
47046 char * kwnames[] = {
47047 (char *) "self",(char *) "item", NULL
47048 };
47049
47050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47052 if (!SWIG_IsOK(res1)) {
47053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47054 }
47055 arg1 = reinterpret_cast< wxSizer * >(argp1);
47056 arg2 = obj1;
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 result = (bool)wxSizer_IsShown(arg1,arg2);
47060 wxPyEndAllowThreads(__tstate);
47061 if (PyErr_Occurred()) SWIG_fail;
47062 }
47063 {
47064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47065 }
47066 return resultobj;
47067 fail:
47068 return NULL;
47069 }
47070
47071
47072 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47073 PyObject *resultobj = 0;
47074 wxSizer *arg1 = (wxSizer *) 0 ;
47075 bool arg2 ;
47076 void *argp1 = 0 ;
47077 int res1 = 0 ;
47078 bool val2 ;
47079 int ecode2 = 0 ;
47080 PyObject * obj0 = 0 ;
47081 PyObject * obj1 = 0 ;
47082 char * kwnames[] = {
47083 (char *) "self",(char *) "show", NULL
47084 };
47085
47086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47088 if (!SWIG_IsOK(res1)) {
47089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47090 }
47091 arg1 = reinterpret_cast< wxSizer * >(argp1);
47092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47093 if (!SWIG_IsOK(ecode2)) {
47094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47095 }
47096 arg2 = static_cast< bool >(val2);
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 (arg1)->ShowItems(arg2);
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = SWIG_Py_Void();
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47111 PyObject *obj;
47112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47113 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47114 return SWIG_Py_Void();
47115 }
47116
47117 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47118 PyObject *resultobj = 0;
47119 wxPySizer *result = 0 ;
47120
47121 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 result = (wxPySizer *)new wxPySizer();
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47129 return resultobj;
47130 fail:
47131 return NULL;
47132 }
47133
47134
47135 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47136 PyObject *resultobj = 0;
47137 wxPySizer *arg1 = (wxPySizer *) 0 ;
47138 PyObject *arg2 = (PyObject *) 0 ;
47139 PyObject *arg3 = (PyObject *) 0 ;
47140 void *argp1 = 0 ;
47141 int res1 = 0 ;
47142 PyObject * obj0 = 0 ;
47143 PyObject * obj1 = 0 ;
47144 PyObject * obj2 = 0 ;
47145 char * kwnames[] = {
47146 (char *) "self",(char *) "self",(char *) "_class", NULL
47147 };
47148
47149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47151 if (!SWIG_IsOK(res1)) {
47152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47153 }
47154 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47155 arg2 = obj1;
47156 arg3 = obj2;
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 (arg1)->_setCallbackInfo(arg2,arg3);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 resultobj = SWIG_Py_Void();
47164 return resultobj;
47165 fail:
47166 return NULL;
47167 }
47168
47169
47170 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47171 PyObject *obj;
47172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47173 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47174 return SWIG_Py_Void();
47175 }
47176
47177 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47178 return SWIG_Python_InitShadowInstance(args);
47179 }
47180
47181 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47182 PyObject *resultobj = 0;
47183 int arg1 = (int) wxHORIZONTAL ;
47184 wxBoxSizer *result = 0 ;
47185 int val1 ;
47186 int ecode1 = 0 ;
47187 PyObject * obj0 = 0 ;
47188 char * kwnames[] = {
47189 (char *) "orient", NULL
47190 };
47191
47192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47193 if (obj0) {
47194 ecode1 = SWIG_AsVal_int(obj0, &val1);
47195 if (!SWIG_IsOK(ecode1)) {
47196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47197 }
47198 arg1 = static_cast< int >(val1);
47199 }
47200 {
47201 PyThreadState* __tstate = wxPyBeginAllowThreads();
47202 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47203 wxPyEndAllowThreads(__tstate);
47204 if (PyErr_Occurred()) SWIG_fail;
47205 }
47206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47207 return resultobj;
47208 fail:
47209 return NULL;
47210 }
47211
47212
47213 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47214 PyObject *resultobj = 0;
47215 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47216 int result;
47217 void *argp1 = 0 ;
47218 int res1 = 0 ;
47219 PyObject *swig_obj[1] ;
47220
47221 if (!args) SWIG_fail;
47222 swig_obj[0] = args;
47223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47224 if (!SWIG_IsOK(res1)) {
47225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47226 }
47227 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47228 {
47229 PyThreadState* __tstate = wxPyBeginAllowThreads();
47230 result = (int)(arg1)->GetOrientation();
47231 wxPyEndAllowThreads(__tstate);
47232 if (PyErr_Occurred()) SWIG_fail;
47233 }
47234 resultobj = SWIG_From_int(static_cast< int >(result));
47235 return resultobj;
47236 fail:
47237 return NULL;
47238 }
47239
47240
47241 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47242 PyObject *resultobj = 0;
47243 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47244 int arg2 ;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 int val2 ;
47248 int ecode2 = 0 ;
47249 PyObject * obj0 = 0 ;
47250 PyObject * obj1 = 0 ;
47251 char * kwnames[] = {
47252 (char *) "self",(char *) "orient", NULL
47253 };
47254
47255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47257 if (!SWIG_IsOK(res1)) {
47258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47259 }
47260 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47261 ecode2 = SWIG_AsVal_int(obj1, &val2);
47262 if (!SWIG_IsOK(ecode2)) {
47263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47264 }
47265 arg2 = static_cast< int >(val2);
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 (arg1)->SetOrientation(arg2);
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_Py_Void();
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47280 PyObject *obj;
47281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47282 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47283 return SWIG_Py_Void();
47284 }
47285
47286 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 return SWIG_Python_InitShadowInstance(args);
47288 }
47289
47290 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47291 PyObject *resultobj = 0;
47292 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47293 int arg2 = (int) wxHORIZONTAL ;
47294 wxStaticBoxSizer *result = 0 ;
47295 void *argp1 = 0 ;
47296 int res1 = 0 ;
47297 int val2 ;
47298 int ecode2 = 0 ;
47299 PyObject * obj0 = 0 ;
47300 PyObject * obj1 = 0 ;
47301 char * kwnames[] = {
47302 (char *) "box",(char *) "orient", NULL
47303 };
47304
47305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47307 if (!SWIG_IsOK(res1)) {
47308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47309 }
47310 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
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_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47315 }
47316 arg2 = static_cast< int >(val2);
47317 }
47318 {
47319 PyThreadState* __tstate = wxPyBeginAllowThreads();
47320 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47321 wxPyEndAllowThreads(__tstate);
47322 if (PyErr_Occurred()) SWIG_fail;
47323 }
47324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47325 return resultobj;
47326 fail:
47327 return NULL;
47328 }
47329
47330
47331 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47332 PyObject *resultobj = 0;
47333 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47334 wxStaticBox *result = 0 ;
47335 void *argp1 = 0 ;
47336 int res1 = 0 ;
47337 PyObject *swig_obj[1] ;
47338
47339 if (!args) SWIG_fail;
47340 swig_obj[0] = args;
47341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47342 if (!SWIG_IsOK(res1)) {
47343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47344 }
47345 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 result = (wxStaticBox *)(arg1)->GetStaticBox();
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 {
47353 resultobj = wxPyMake_wxObject(result, (bool)0);
47354 }
47355 return resultobj;
47356 fail:
47357 return NULL;
47358 }
47359
47360
47361 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47362 PyObject *obj;
47363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47364 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47365 return SWIG_Py_Void();
47366 }
47367
47368 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47369 return SWIG_Python_InitShadowInstance(args);
47370 }
47371
47372 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47373 PyObject *resultobj = 0;
47374 int arg1 = (int) 1 ;
47375 int arg2 = (int) 0 ;
47376 int arg3 = (int) 0 ;
47377 int arg4 = (int) 0 ;
47378 wxGridSizer *result = 0 ;
47379 int val1 ;
47380 int ecode1 = 0 ;
47381 int val2 ;
47382 int ecode2 = 0 ;
47383 int val3 ;
47384 int ecode3 = 0 ;
47385 int val4 ;
47386 int ecode4 = 0 ;
47387 PyObject * obj0 = 0 ;
47388 PyObject * obj1 = 0 ;
47389 PyObject * obj2 = 0 ;
47390 PyObject * obj3 = 0 ;
47391 char * kwnames[] = {
47392 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47393 };
47394
47395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47396 if (obj0) {
47397 ecode1 = SWIG_AsVal_int(obj0, &val1);
47398 if (!SWIG_IsOK(ecode1)) {
47399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47400 }
47401 arg1 = static_cast< int >(val1);
47402 }
47403 if (obj1) {
47404 ecode2 = SWIG_AsVal_int(obj1, &val2);
47405 if (!SWIG_IsOK(ecode2)) {
47406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47407 }
47408 arg2 = static_cast< int >(val2);
47409 }
47410 if (obj2) {
47411 ecode3 = SWIG_AsVal_int(obj2, &val3);
47412 if (!SWIG_IsOK(ecode3)) {
47413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47414 }
47415 arg3 = static_cast< int >(val3);
47416 }
47417 if (obj3) {
47418 ecode4 = SWIG_AsVal_int(obj3, &val4);
47419 if (!SWIG_IsOK(ecode4)) {
47420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47421 }
47422 arg4 = static_cast< int >(val4);
47423 }
47424 {
47425 PyThreadState* __tstate = wxPyBeginAllowThreads();
47426 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47427 wxPyEndAllowThreads(__tstate);
47428 if (PyErr_Occurred()) SWIG_fail;
47429 }
47430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47431 return resultobj;
47432 fail:
47433 return NULL;
47434 }
47435
47436
47437 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47438 PyObject *resultobj = 0;
47439 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47440 int arg2 ;
47441 void *argp1 = 0 ;
47442 int res1 = 0 ;
47443 int val2 ;
47444 int ecode2 = 0 ;
47445 PyObject * obj0 = 0 ;
47446 PyObject * obj1 = 0 ;
47447 char * kwnames[] = {
47448 (char *) "self",(char *) "cols", NULL
47449 };
47450
47451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47453 if (!SWIG_IsOK(res1)) {
47454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47455 }
47456 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47457 ecode2 = SWIG_AsVal_int(obj1, &val2);
47458 if (!SWIG_IsOK(ecode2)) {
47459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47460 }
47461 arg2 = static_cast< int >(val2);
47462 {
47463 PyThreadState* __tstate = wxPyBeginAllowThreads();
47464 (arg1)->SetCols(arg2);
47465 wxPyEndAllowThreads(__tstate);
47466 if (PyErr_Occurred()) SWIG_fail;
47467 }
47468 resultobj = SWIG_Py_Void();
47469 return resultobj;
47470 fail:
47471 return NULL;
47472 }
47473
47474
47475 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47476 PyObject *resultobj = 0;
47477 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47478 int arg2 ;
47479 void *argp1 = 0 ;
47480 int res1 = 0 ;
47481 int val2 ;
47482 int ecode2 = 0 ;
47483 PyObject * obj0 = 0 ;
47484 PyObject * obj1 = 0 ;
47485 char * kwnames[] = {
47486 (char *) "self",(char *) "rows", NULL
47487 };
47488
47489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47491 if (!SWIG_IsOK(res1)) {
47492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47493 }
47494 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47495 ecode2 = SWIG_AsVal_int(obj1, &val2);
47496 if (!SWIG_IsOK(ecode2)) {
47497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47498 }
47499 arg2 = static_cast< int >(val2);
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 (arg1)->SetRows(arg2);
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 resultobj = SWIG_Py_Void();
47507 return resultobj;
47508 fail:
47509 return NULL;
47510 }
47511
47512
47513 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47514 PyObject *resultobj = 0;
47515 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47516 int arg2 ;
47517 void *argp1 = 0 ;
47518 int res1 = 0 ;
47519 int val2 ;
47520 int ecode2 = 0 ;
47521 PyObject * obj0 = 0 ;
47522 PyObject * obj1 = 0 ;
47523 char * kwnames[] = {
47524 (char *) "self",(char *) "gap", NULL
47525 };
47526
47527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47531 }
47532 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47533 ecode2 = SWIG_AsVal_int(obj1, &val2);
47534 if (!SWIG_IsOK(ecode2)) {
47535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47536 }
47537 arg2 = static_cast< int >(val2);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 (arg1)->SetVGap(arg2);
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_Py_Void();
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47552 PyObject *resultobj = 0;
47553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47554 int arg2 ;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 int val2 ;
47558 int ecode2 = 0 ;
47559 PyObject * obj0 = 0 ;
47560 PyObject * obj1 = 0 ;
47561 char * kwnames[] = {
47562 (char *) "self",(char *) "gap", NULL
47563 };
47564
47565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47567 if (!SWIG_IsOK(res1)) {
47568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47569 }
47570 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47571 ecode2 = SWIG_AsVal_int(obj1, &val2);
47572 if (!SWIG_IsOK(ecode2)) {
47573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47574 }
47575 arg2 = static_cast< int >(val2);
47576 {
47577 PyThreadState* __tstate = wxPyBeginAllowThreads();
47578 (arg1)->SetHGap(arg2);
47579 wxPyEndAllowThreads(__tstate);
47580 if (PyErr_Occurred()) SWIG_fail;
47581 }
47582 resultobj = SWIG_Py_Void();
47583 return resultobj;
47584 fail:
47585 return NULL;
47586 }
47587
47588
47589 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47590 PyObject *resultobj = 0;
47591 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47592 int result;
47593 void *argp1 = 0 ;
47594 int res1 = 0 ;
47595 PyObject *swig_obj[1] ;
47596
47597 if (!args) SWIG_fail;
47598 swig_obj[0] = args;
47599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47602 }
47603 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47604 {
47605 PyThreadState* __tstate = wxPyBeginAllowThreads();
47606 result = (int)(arg1)->GetCols();
47607 wxPyEndAllowThreads(__tstate);
47608 if (PyErr_Occurred()) SWIG_fail;
47609 }
47610 resultobj = SWIG_From_int(static_cast< int >(result));
47611 return resultobj;
47612 fail:
47613 return NULL;
47614 }
47615
47616
47617 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47618 PyObject *resultobj = 0;
47619 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47620 int result;
47621 void *argp1 = 0 ;
47622 int res1 = 0 ;
47623 PyObject *swig_obj[1] ;
47624
47625 if (!args) SWIG_fail;
47626 swig_obj[0] = args;
47627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47628 if (!SWIG_IsOK(res1)) {
47629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47630 }
47631 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47632 {
47633 PyThreadState* __tstate = wxPyBeginAllowThreads();
47634 result = (int)(arg1)->GetRows();
47635 wxPyEndAllowThreads(__tstate);
47636 if (PyErr_Occurred()) SWIG_fail;
47637 }
47638 resultobj = SWIG_From_int(static_cast< int >(result));
47639 return resultobj;
47640 fail:
47641 return NULL;
47642 }
47643
47644
47645 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47646 PyObject *resultobj = 0;
47647 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47648 int result;
47649 void *argp1 = 0 ;
47650 int res1 = 0 ;
47651 PyObject *swig_obj[1] ;
47652
47653 if (!args) SWIG_fail;
47654 swig_obj[0] = args;
47655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47656 if (!SWIG_IsOK(res1)) {
47657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47658 }
47659 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47660 {
47661 PyThreadState* __tstate = wxPyBeginAllowThreads();
47662 result = (int)(arg1)->GetVGap();
47663 wxPyEndAllowThreads(__tstate);
47664 if (PyErr_Occurred()) SWIG_fail;
47665 }
47666 resultobj = SWIG_From_int(static_cast< int >(result));
47667 return resultobj;
47668 fail:
47669 return NULL;
47670 }
47671
47672
47673 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47674 PyObject *resultobj = 0;
47675 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47676 int result;
47677 void *argp1 = 0 ;
47678 int res1 = 0 ;
47679 PyObject *swig_obj[1] ;
47680
47681 if (!args) SWIG_fail;
47682 swig_obj[0] = args;
47683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47684 if (!SWIG_IsOK(res1)) {
47685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47686 }
47687 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47688 {
47689 PyThreadState* __tstate = wxPyBeginAllowThreads();
47690 result = (int)(arg1)->GetHGap();
47691 wxPyEndAllowThreads(__tstate);
47692 if (PyErr_Occurred()) SWIG_fail;
47693 }
47694 resultobj = SWIG_From_int(static_cast< int >(result));
47695 return resultobj;
47696 fail:
47697 return NULL;
47698 }
47699
47700
47701 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47702 PyObject *obj;
47703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47704 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47705 return SWIG_Py_Void();
47706 }
47707
47708 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47709 return SWIG_Python_InitShadowInstance(args);
47710 }
47711
47712 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47713 PyObject *resultobj = 0;
47714 int arg1 = (int) 1 ;
47715 int arg2 = (int) 0 ;
47716 int arg3 = (int) 0 ;
47717 int arg4 = (int) 0 ;
47718 wxFlexGridSizer *result = 0 ;
47719 int val1 ;
47720 int ecode1 = 0 ;
47721 int val2 ;
47722 int ecode2 = 0 ;
47723 int val3 ;
47724 int ecode3 = 0 ;
47725 int val4 ;
47726 int ecode4 = 0 ;
47727 PyObject * obj0 = 0 ;
47728 PyObject * obj1 = 0 ;
47729 PyObject * obj2 = 0 ;
47730 PyObject * obj3 = 0 ;
47731 char * kwnames[] = {
47732 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47733 };
47734
47735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47736 if (obj0) {
47737 ecode1 = SWIG_AsVal_int(obj0, &val1);
47738 if (!SWIG_IsOK(ecode1)) {
47739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47740 }
47741 arg1 = static_cast< int >(val1);
47742 }
47743 if (obj1) {
47744 ecode2 = SWIG_AsVal_int(obj1, &val2);
47745 if (!SWIG_IsOK(ecode2)) {
47746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47747 }
47748 arg2 = static_cast< int >(val2);
47749 }
47750 if (obj2) {
47751 ecode3 = SWIG_AsVal_int(obj2, &val3);
47752 if (!SWIG_IsOK(ecode3)) {
47753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47754 }
47755 arg3 = static_cast< int >(val3);
47756 }
47757 if (obj3) {
47758 ecode4 = SWIG_AsVal_int(obj3, &val4);
47759 if (!SWIG_IsOK(ecode4)) {
47760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47761 }
47762 arg4 = static_cast< int >(val4);
47763 }
47764 {
47765 PyThreadState* __tstate = wxPyBeginAllowThreads();
47766 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47767 wxPyEndAllowThreads(__tstate);
47768 if (PyErr_Occurred()) SWIG_fail;
47769 }
47770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47771 return resultobj;
47772 fail:
47773 return NULL;
47774 }
47775
47776
47777 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47778 PyObject *resultobj = 0;
47779 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47780 size_t arg2 ;
47781 int arg3 = (int) 0 ;
47782 void *argp1 = 0 ;
47783 int res1 = 0 ;
47784 size_t val2 ;
47785 int ecode2 = 0 ;
47786 int val3 ;
47787 int ecode3 = 0 ;
47788 PyObject * obj0 = 0 ;
47789 PyObject * obj1 = 0 ;
47790 PyObject * obj2 = 0 ;
47791 char * kwnames[] = {
47792 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47793 };
47794
47795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47797 if (!SWIG_IsOK(res1)) {
47798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47799 }
47800 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47801 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47802 if (!SWIG_IsOK(ecode2)) {
47803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47804 }
47805 arg2 = static_cast< size_t >(val2);
47806 if (obj2) {
47807 ecode3 = SWIG_AsVal_int(obj2, &val3);
47808 if (!SWIG_IsOK(ecode3)) {
47809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47810 }
47811 arg3 = static_cast< int >(val3);
47812 }
47813 {
47814 PyThreadState* __tstate = wxPyBeginAllowThreads();
47815 (arg1)->AddGrowableRow(arg2,arg3);
47816 wxPyEndAllowThreads(__tstate);
47817 if (PyErr_Occurred()) SWIG_fail;
47818 }
47819 resultobj = SWIG_Py_Void();
47820 return resultobj;
47821 fail:
47822 return NULL;
47823 }
47824
47825
47826 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47827 PyObject *resultobj = 0;
47828 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47829 size_t arg2 ;
47830 void *argp1 = 0 ;
47831 int res1 = 0 ;
47832 size_t val2 ;
47833 int ecode2 = 0 ;
47834 PyObject * obj0 = 0 ;
47835 PyObject * obj1 = 0 ;
47836 char * kwnames[] = {
47837 (char *) "self",(char *) "idx", NULL
47838 };
47839
47840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47842 if (!SWIG_IsOK(res1)) {
47843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47844 }
47845 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47846 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47847 if (!SWIG_IsOK(ecode2)) {
47848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47849 }
47850 arg2 = static_cast< size_t >(val2);
47851 {
47852 PyThreadState* __tstate = wxPyBeginAllowThreads();
47853 (arg1)->RemoveGrowableRow(arg2);
47854 wxPyEndAllowThreads(__tstate);
47855 if (PyErr_Occurred()) SWIG_fail;
47856 }
47857 resultobj = SWIG_Py_Void();
47858 return resultobj;
47859 fail:
47860 return NULL;
47861 }
47862
47863
47864 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47865 PyObject *resultobj = 0;
47866 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47867 size_t arg2 ;
47868 int arg3 = (int) 0 ;
47869 void *argp1 = 0 ;
47870 int res1 = 0 ;
47871 size_t val2 ;
47872 int ecode2 = 0 ;
47873 int val3 ;
47874 int ecode3 = 0 ;
47875 PyObject * obj0 = 0 ;
47876 PyObject * obj1 = 0 ;
47877 PyObject * obj2 = 0 ;
47878 char * kwnames[] = {
47879 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47880 };
47881
47882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47884 if (!SWIG_IsOK(res1)) {
47885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47886 }
47887 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47889 if (!SWIG_IsOK(ecode2)) {
47890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47891 }
47892 arg2 = static_cast< size_t >(val2);
47893 if (obj2) {
47894 ecode3 = SWIG_AsVal_int(obj2, &val3);
47895 if (!SWIG_IsOK(ecode3)) {
47896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47897 }
47898 arg3 = static_cast< int >(val3);
47899 }
47900 {
47901 PyThreadState* __tstate = wxPyBeginAllowThreads();
47902 (arg1)->AddGrowableCol(arg2,arg3);
47903 wxPyEndAllowThreads(__tstate);
47904 if (PyErr_Occurred()) SWIG_fail;
47905 }
47906 resultobj = SWIG_Py_Void();
47907 return resultobj;
47908 fail:
47909 return NULL;
47910 }
47911
47912
47913 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47914 PyObject *resultobj = 0;
47915 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47916 size_t arg2 ;
47917 void *argp1 = 0 ;
47918 int res1 = 0 ;
47919 size_t val2 ;
47920 int ecode2 = 0 ;
47921 PyObject * obj0 = 0 ;
47922 PyObject * obj1 = 0 ;
47923 char * kwnames[] = {
47924 (char *) "self",(char *) "idx", NULL
47925 };
47926
47927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47929 if (!SWIG_IsOK(res1)) {
47930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47931 }
47932 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47933 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47934 if (!SWIG_IsOK(ecode2)) {
47935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47936 }
47937 arg2 = static_cast< size_t >(val2);
47938 {
47939 PyThreadState* __tstate = wxPyBeginAllowThreads();
47940 (arg1)->RemoveGrowableCol(arg2);
47941 wxPyEndAllowThreads(__tstate);
47942 if (PyErr_Occurred()) SWIG_fail;
47943 }
47944 resultobj = SWIG_Py_Void();
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47952 PyObject *resultobj = 0;
47953 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47954 int arg2 ;
47955 void *argp1 = 0 ;
47956 int res1 = 0 ;
47957 int val2 ;
47958 int ecode2 = 0 ;
47959 PyObject * obj0 = 0 ;
47960 PyObject * obj1 = 0 ;
47961 char * kwnames[] = {
47962 (char *) "self",(char *) "direction", NULL
47963 };
47964
47965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47967 if (!SWIG_IsOK(res1)) {
47968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47969 }
47970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47971 ecode2 = SWIG_AsVal_int(obj1, &val2);
47972 if (!SWIG_IsOK(ecode2)) {
47973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47974 }
47975 arg2 = static_cast< int >(val2);
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 (arg1)->SetFlexibleDirection(arg2);
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_Py_Void();
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47990 PyObject *resultobj = 0;
47991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47992 int result;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 PyObject *swig_obj[1] ;
47996
47997 if (!args) SWIG_fail;
47998 swig_obj[0] = args;
47999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48002 }
48003 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48004 {
48005 PyThreadState* __tstate = wxPyBeginAllowThreads();
48006 result = (int)(arg1)->GetFlexibleDirection();
48007 wxPyEndAllowThreads(__tstate);
48008 if (PyErr_Occurred()) SWIG_fail;
48009 }
48010 resultobj = SWIG_From_int(static_cast< int >(result));
48011 return resultobj;
48012 fail:
48013 return NULL;
48014 }
48015
48016
48017 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48018 PyObject *resultobj = 0;
48019 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48020 wxFlexSizerGrowMode arg2 ;
48021 void *argp1 = 0 ;
48022 int res1 = 0 ;
48023 int val2 ;
48024 int ecode2 = 0 ;
48025 PyObject * obj0 = 0 ;
48026 PyObject * obj1 = 0 ;
48027 char * kwnames[] = {
48028 (char *) "self",(char *) "mode", NULL
48029 };
48030
48031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48037 ecode2 = SWIG_AsVal_int(obj1, &val2);
48038 if (!SWIG_IsOK(ecode2)) {
48039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48040 }
48041 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48042 {
48043 PyThreadState* __tstate = wxPyBeginAllowThreads();
48044 (arg1)->SetNonFlexibleGrowMode(arg2);
48045 wxPyEndAllowThreads(__tstate);
48046 if (PyErr_Occurred()) SWIG_fail;
48047 }
48048 resultobj = SWIG_Py_Void();
48049 return resultobj;
48050 fail:
48051 return NULL;
48052 }
48053
48054
48055 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48056 PyObject *resultobj = 0;
48057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48058 wxFlexSizerGrowMode result;
48059 void *argp1 = 0 ;
48060 int res1 = 0 ;
48061 PyObject *swig_obj[1] ;
48062
48063 if (!args) SWIG_fail;
48064 swig_obj[0] = args;
48065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48066 if (!SWIG_IsOK(res1)) {
48067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48068 }
48069 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48070 {
48071 PyThreadState* __tstate = wxPyBeginAllowThreads();
48072 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48073 wxPyEndAllowThreads(__tstate);
48074 if (PyErr_Occurred()) SWIG_fail;
48075 }
48076 resultobj = SWIG_From_int(static_cast< int >(result));
48077 return resultobj;
48078 fail:
48079 return NULL;
48080 }
48081
48082
48083 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48084 PyObject *resultobj = 0;
48085 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48086 wxArrayInt *result = 0 ;
48087 void *argp1 = 0 ;
48088 int res1 = 0 ;
48089 PyObject *swig_obj[1] ;
48090
48091 if (!args) SWIG_fail;
48092 swig_obj[0] = args;
48093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48094 if (!SWIG_IsOK(res1)) {
48095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48096 }
48097 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48098 {
48099 PyThreadState* __tstate = wxPyBeginAllowThreads();
48100 {
48101 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48102 result = (wxArrayInt *) &_result_ref;
48103 }
48104 wxPyEndAllowThreads(__tstate);
48105 if (PyErr_Occurred()) SWIG_fail;
48106 }
48107 {
48108 resultobj = PyList_New(0);
48109 size_t idx;
48110 for (idx = 0; idx < result->GetCount(); idx += 1) {
48111 PyObject* val = PyInt_FromLong( result->Item(idx) );
48112 PyList_Append(resultobj, val);
48113 Py_DECREF(val);
48114 }
48115 }
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48123 PyObject *resultobj = 0;
48124 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48125 wxArrayInt *result = 0 ;
48126 void *argp1 = 0 ;
48127 int res1 = 0 ;
48128 PyObject *swig_obj[1] ;
48129
48130 if (!args) SWIG_fail;
48131 swig_obj[0] = args;
48132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48133 if (!SWIG_IsOK(res1)) {
48134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48135 }
48136 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48137 {
48138 PyThreadState* __tstate = wxPyBeginAllowThreads();
48139 {
48140 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48141 result = (wxArrayInt *) &_result_ref;
48142 }
48143 wxPyEndAllowThreads(__tstate);
48144 if (PyErr_Occurred()) SWIG_fail;
48145 }
48146 {
48147 resultobj = PyList_New(0);
48148 size_t idx;
48149 for (idx = 0; idx < result->GetCount(); idx += 1) {
48150 PyObject* val = PyInt_FromLong( result->Item(idx) );
48151 PyList_Append(resultobj, val);
48152 Py_DECREF(val);
48153 }
48154 }
48155 return resultobj;
48156 fail:
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48162 PyObject *obj;
48163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48164 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48165 return SWIG_Py_Void();
48166 }
48167
48168 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48169 return SWIG_Python_InitShadowInstance(args);
48170 }
48171
48172 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48173 PyObject *resultobj = 0;
48174 wxStdDialogButtonSizer *result = 0 ;
48175
48176 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48177 {
48178 PyThreadState* __tstate = wxPyBeginAllowThreads();
48179 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48180 wxPyEndAllowThreads(__tstate);
48181 if (PyErr_Occurred()) SWIG_fail;
48182 }
48183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48184 return resultobj;
48185 fail:
48186 return NULL;
48187 }
48188
48189
48190 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48191 PyObject *resultobj = 0;
48192 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48193 wxButton *arg2 = (wxButton *) 0 ;
48194 void *argp1 = 0 ;
48195 int res1 = 0 ;
48196 void *argp2 = 0 ;
48197 int res2 = 0 ;
48198 PyObject * obj0 = 0 ;
48199 PyObject * obj1 = 0 ;
48200 char * kwnames[] = {
48201 (char *) "self",(char *) "button", NULL
48202 };
48203
48204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48206 if (!SWIG_IsOK(res1)) {
48207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48208 }
48209 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48211 if (!SWIG_IsOK(res2)) {
48212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48213 }
48214 arg2 = reinterpret_cast< wxButton * >(argp2);
48215 {
48216 PyThreadState* __tstate = wxPyBeginAllowThreads();
48217 (arg1)->AddButton(arg2);
48218 wxPyEndAllowThreads(__tstate);
48219 if (PyErr_Occurred()) SWIG_fail;
48220 }
48221 resultobj = SWIG_Py_Void();
48222 return resultobj;
48223 fail:
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48229 PyObject *resultobj = 0;
48230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 PyObject *swig_obj[1] ;
48234
48235 if (!args) SWIG_fail;
48236 swig_obj[0] = args;
48237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48240 }
48241 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48242 {
48243 PyThreadState* __tstate = wxPyBeginAllowThreads();
48244 (arg1)->Realize();
48245 wxPyEndAllowThreads(__tstate);
48246 if (PyErr_Occurred()) SWIG_fail;
48247 }
48248 resultobj = SWIG_Py_Void();
48249 return resultobj;
48250 fail:
48251 return NULL;
48252 }
48253
48254
48255 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48256 PyObject *resultobj = 0;
48257 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48258 wxButton *arg2 = (wxButton *) 0 ;
48259 void *argp1 = 0 ;
48260 int res1 = 0 ;
48261 void *argp2 = 0 ;
48262 int res2 = 0 ;
48263 PyObject * obj0 = 0 ;
48264 PyObject * obj1 = 0 ;
48265 char * kwnames[] = {
48266 (char *) "self",(char *) "button", NULL
48267 };
48268
48269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48271 if (!SWIG_IsOK(res1)) {
48272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48273 }
48274 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48276 if (!SWIG_IsOK(res2)) {
48277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48278 }
48279 arg2 = reinterpret_cast< wxButton * >(argp2);
48280 {
48281 PyThreadState* __tstate = wxPyBeginAllowThreads();
48282 (arg1)->SetAffirmativeButton(arg2);
48283 wxPyEndAllowThreads(__tstate);
48284 if (PyErr_Occurred()) SWIG_fail;
48285 }
48286 resultobj = SWIG_Py_Void();
48287 return resultobj;
48288 fail:
48289 return NULL;
48290 }
48291
48292
48293 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48294 PyObject *resultobj = 0;
48295 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48296 wxButton *arg2 = (wxButton *) 0 ;
48297 void *argp1 = 0 ;
48298 int res1 = 0 ;
48299 void *argp2 = 0 ;
48300 int res2 = 0 ;
48301 PyObject * obj0 = 0 ;
48302 PyObject * obj1 = 0 ;
48303 char * kwnames[] = {
48304 (char *) "self",(char *) "button", NULL
48305 };
48306
48307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48309 if (!SWIG_IsOK(res1)) {
48310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48311 }
48312 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48314 if (!SWIG_IsOK(res2)) {
48315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48316 }
48317 arg2 = reinterpret_cast< wxButton * >(argp2);
48318 {
48319 PyThreadState* __tstate = wxPyBeginAllowThreads();
48320 (arg1)->SetNegativeButton(arg2);
48321 wxPyEndAllowThreads(__tstate);
48322 if (PyErr_Occurred()) SWIG_fail;
48323 }
48324 resultobj = SWIG_Py_Void();
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48332 PyObject *resultobj = 0;
48333 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48334 wxButton *arg2 = (wxButton *) 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 void *argp2 = 0 ;
48338 int res2 = 0 ;
48339 PyObject * obj0 = 0 ;
48340 PyObject * obj1 = 0 ;
48341 char * kwnames[] = {
48342 (char *) "self",(char *) "button", NULL
48343 };
48344
48345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48347 if (!SWIG_IsOK(res1)) {
48348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48349 }
48350 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48352 if (!SWIG_IsOK(res2)) {
48353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48354 }
48355 arg2 = reinterpret_cast< wxButton * >(argp2);
48356 {
48357 PyThreadState* __tstate = wxPyBeginAllowThreads();
48358 (arg1)->SetCancelButton(arg2);
48359 wxPyEndAllowThreads(__tstate);
48360 if (PyErr_Occurred()) SWIG_fail;
48361 }
48362 resultobj = SWIG_Py_Void();
48363 return resultobj;
48364 fail:
48365 return NULL;
48366 }
48367
48368
48369 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48370 PyObject *resultobj = 0;
48371 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48372 wxButton *result = 0 ;
48373 void *argp1 = 0 ;
48374 int res1 = 0 ;
48375 PyObject *swig_obj[1] ;
48376
48377 if (!args) SWIG_fail;
48378 swig_obj[0] = args;
48379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48380 if (!SWIG_IsOK(res1)) {
48381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48382 }
48383 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48384 {
48385 PyThreadState* __tstate = wxPyBeginAllowThreads();
48386 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48387 wxPyEndAllowThreads(__tstate);
48388 if (PyErr_Occurred()) SWIG_fail;
48389 }
48390 {
48391 resultobj = wxPyMake_wxObject(result, (bool)0);
48392 }
48393 return resultobj;
48394 fail:
48395 return NULL;
48396 }
48397
48398
48399 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48400 PyObject *resultobj = 0;
48401 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48402 wxButton *result = 0 ;
48403 void *argp1 = 0 ;
48404 int res1 = 0 ;
48405 PyObject *swig_obj[1] ;
48406
48407 if (!args) SWIG_fail;
48408 swig_obj[0] = args;
48409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48410 if (!SWIG_IsOK(res1)) {
48411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48412 }
48413 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48414 {
48415 PyThreadState* __tstate = wxPyBeginAllowThreads();
48416 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48417 wxPyEndAllowThreads(__tstate);
48418 if (PyErr_Occurred()) SWIG_fail;
48419 }
48420 {
48421 resultobj = wxPyMake_wxObject(result, (bool)0);
48422 }
48423 return resultobj;
48424 fail:
48425 return NULL;
48426 }
48427
48428
48429 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48430 PyObject *resultobj = 0;
48431 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48432 wxButton *result = 0 ;
48433 void *argp1 = 0 ;
48434 int res1 = 0 ;
48435 PyObject *swig_obj[1] ;
48436
48437 if (!args) SWIG_fail;
48438 swig_obj[0] = args;
48439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48440 if (!SWIG_IsOK(res1)) {
48441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48442 }
48443 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48444 {
48445 PyThreadState* __tstate = wxPyBeginAllowThreads();
48446 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48447 wxPyEndAllowThreads(__tstate);
48448 if (PyErr_Occurred()) SWIG_fail;
48449 }
48450 {
48451 resultobj = wxPyMake_wxObject(result, (bool)0);
48452 }
48453 return resultobj;
48454 fail:
48455 return NULL;
48456 }
48457
48458
48459 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48460 PyObject *resultobj = 0;
48461 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48462 wxButton *result = 0 ;
48463 void *argp1 = 0 ;
48464 int res1 = 0 ;
48465 PyObject *swig_obj[1] ;
48466
48467 if (!args) SWIG_fail;
48468 swig_obj[0] = args;
48469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48470 if (!SWIG_IsOK(res1)) {
48471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48472 }
48473 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48474 {
48475 PyThreadState* __tstate = wxPyBeginAllowThreads();
48476 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48477 wxPyEndAllowThreads(__tstate);
48478 if (PyErr_Occurred()) SWIG_fail;
48479 }
48480 {
48481 resultobj = wxPyMake_wxObject(result, (bool)0);
48482 }
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48490 PyObject *resultobj = 0;
48491 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48492 wxButton *result = 0 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 PyObject *swig_obj[1] ;
48496
48497 if (!args) SWIG_fail;
48498 swig_obj[0] = args;
48499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48500 if (!SWIG_IsOK(res1)) {
48501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48502 }
48503 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48504 {
48505 PyThreadState* __tstate = wxPyBeginAllowThreads();
48506 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48507 wxPyEndAllowThreads(__tstate);
48508 if (PyErr_Occurred()) SWIG_fail;
48509 }
48510 {
48511 resultobj = wxPyMake_wxObject(result, (bool)0);
48512 }
48513 return resultobj;
48514 fail:
48515 return NULL;
48516 }
48517
48518
48519 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48520 PyObject *obj;
48521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48522 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48523 return SWIG_Py_Void();
48524 }
48525
48526 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48527 return SWIG_Python_InitShadowInstance(args);
48528 }
48529
48530 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48531 PyObject *resultobj = 0;
48532 int arg1 = (int) 0 ;
48533 int arg2 = (int) 0 ;
48534 wxGBPosition *result = 0 ;
48535 int val1 ;
48536 int ecode1 = 0 ;
48537 int val2 ;
48538 int ecode2 = 0 ;
48539 PyObject * obj0 = 0 ;
48540 PyObject * obj1 = 0 ;
48541 char * kwnames[] = {
48542 (char *) "row",(char *) "col", NULL
48543 };
48544
48545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48546 if (obj0) {
48547 ecode1 = SWIG_AsVal_int(obj0, &val1);
48548 if (!SWIG_IsOK(ecode1)) {
48549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48550 }
48551 arg1 = static_cast< int >(val1);
48552 }
48553 if (obj1) {
48554 ecode2 = SWIG_AsVal_int(obj1, &val2);
48555 if (!SWIG_IsOK(ecode2)) {
48556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48557 }
48558 arg2 = static_cast< int >(val2);
48559 }
48560 {
48561 PyThreadState* __tstate = wxPyBeginAllowThreads();
48562 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48563 wxPyEndAllowThreads(__tstate);
48564 if (PyErr_Occurred()) SWIG_fail;
48565 }
48566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48567 return resultobj;
48568 fail:
48569 return NULL;
48570 }
48571
48572
48573 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48574 PyObject *resultobj = 0;
48575 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48576 void *argp1 = 0 ;
48577 int res1 = 0 ;
48578 PyObject *swig_obj[1] ;
48579
48580 if (!args) SWIG_fail;
48581 swig_obj[0] = args;
48582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48583 if (!SWIG_IsOK(res1)) {
48584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48585 }
48586 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48587 {
48588 PyThreadState* __tstate = wxPyBeginAllowThreads();
48589 delete arg1;
48590
48591 wxPyEndAllowThreads(__tstate);
48592 if (PyErr_Occurred()) SWIG_fail;
48593 }
48594 resultobj = SWIG_Py_Void();
48595 return resultobj;
48596 fail:
48597 return NULL;
48598 }
48599
48600
48601 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48602 PyObject *resultobj = 0;
48603 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48604 int result;
48605 void *argp1 = 0 ;
48606 int res1 = 0 ;
48607 PyObject *swig_obj[1] ;
48608
48609 if (!args) SWIG_fail;
48610 swig_obj[0] = args;
48611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48612 if (!SWIG_IsOK(res1)) {
48613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48614 }
48615 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48616 {
48617 PyThreadState* __tstate = wxPyBeginAllowThreads();
48618 result = (int)((wxGBPosition const *)arg1)->GetRow();
48619 wxPyEndAllowThreads(__tstate);
48620 if (PyErr_Occurred()) SWIG_fail;
48621 }
48622 resultobj = SWIG_From_int(static_cast< int >(result));
48623 return resultobj;
48624 fail:
48625 return NULL;
48626 }
48627
48628
48629 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48630 PyObject *resultobj = 0;
48631 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48632 int result;
48633 void *argp1 = 0 ;
48634 int res1 = 0 ;
48635 PyObject *swig_obj[1] ;
48636
48637 if (!args) SWIG_fail;
48638 swig_obj[0] = args;
48639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48640 if (!SWIG_IsOK(res1)) {
48641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48642 }
48643 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48644 {
48645 PyThreadState* __tstate = wxPyBeginAllowThreads();
48646 result = (int)((wxGBPosition const *)arg1)->GetCol();
48647 wxPyEndAllowThreads(__tstate);
48648 if (PyErr_Occurred()) SWIG_fail;
48649 }
48650 resultobj = SWIG_From_int(static_cast< int >(result));
48651 return resultobj;
48652 fail:
48653 return NULL;
48654 }
48655
48656
48657 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48658 PyObject *resultobj = 0;
48659 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48660 int arg2 ;
48661 void *argp1 = 0 ;
48662 int res1 = 0 ;
48663 int val2 ;
48664 int ecode2 = 0 ;
48665 PyObject * obj0 = 0 ;
48666 PyObject * obj1 = 0 ;
48667 char * kwnames[] = {
48668 (char *) "self",(char *) "row", NULL
48669 };
48670
48671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48673 if (!SWIG_IsOK(res1)) {
48674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48675 }
48676 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48677 ecode2 = SWIG_AsVal_int(obj1, &val2);
48678 if (!SWIG_IsOK(ecode2)) {
48679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48680 }
48681 arg2 = static_cast< int >(val2);
48682 {
48683 PyThreadState* __tstate = wxPyBeginAllowThreads();
48684 (arg1)->SetRow(arg2);
48685 wxPyEndAllowThreads(__tstate);
48686 if (PyErr_Occurred()) SWIG_fail;
48687 }
48688 resultobj = SWIG_Py_Void();
48689 return resultobj;
48690 fail:
48691 return NULL;
48692 }
48693
48694
48695 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48696 PyObject *resultobj = 0;
48697 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48698 int arg2 ;
48699 void *argp1 = 0 ;
48700 int res1 = 0 ;
48701 int val2 ;
48702 int ecode2 = 0 ;
48703 PyObject * obj0 = 0 ;
48704 PyObject * obj1 = 0 ;
48705 char * kwnames[] = {
48706 (char *) "self",(char *) "col", NULL
48707 };
48708
48709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48711 if (!SWIG_IsOK(res1)) {
48712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48713 }
48714 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48715 ecode2 = SWIG_AsVal_int(obj1, &val2);
48716 if (!SWIG_IsOK(ecode2)) {
48717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48718 }
48719 arg2 = static_cast< int >(val2);
48720 {
48721 PyThreadState* __tstate = wxPyBeginAllowThreads();
48722 (arg1)->SetCol(arg2);
48723 wxPyEndAllowThreads(__tstate);
48724 if (PyErr_Occurred()) SWIG_fail;
48725 }
48726 resultobj = SWIG_Py_Void();
48727 return resultobj;
48728 fail:
48729 return NULL;
48730 }
48731
48732
48733 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48734 PyObject *resultobj = 0;
48735 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48736 PyObject *arg2 = (PyObject *) 0 ;
48737 bool result;
48738 void *argp1 = 0 ;
48739 int res1 = 0 ;
48740 PyObject * obj0 = 0 ;
48741 PyObject * obj1 = 0 ;
48742 char * kwnames[] = {
48743 (char *) "self",(char *) "other", NULL
48744 };
48745
48746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48748 if (!SWIG_IsOK(res1)) {
48749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48750 }
48751 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48752 arg2 = obj1;
48753 {
48754 result = (bool)wxGBPosition___eq__(arg1,arg2);
48755 if (PyErr_Occurred()) SWIG_fail;
48756 }
48757 {
48758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48759 }
48760 return resultobj;
48761 fail:
48762 return NULL;
48763 }
48764
48765
48766 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48767 PyObject *resultobj = 0;
48768 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48769 PyObject *arg2 = (PyObject *) 0 ;
48770 bool result;
48771 void *argp1 = 0 ;
48772 int res1 = 0 ;
48773 PyObject * obj0 = 0 ;
48774 PyObject * obj1 = 0 ;
48775 char * kwnames[] = {
48776 (char *) "self",(char *) "other", NULL
48777 };
48778
48779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48783 }
48784 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48785 arg2 = obj1;
48786 {
48787 result = (bool)wxGBPosition___ne__(arg1,arg2);
48788 if (PyErr_Occurred()) SWIG_fail;
48789 }
48790 {
48791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48792 }
48793 return resultobj;
48794 fail:
48795 return NULL;
48796 }
48797
48798
48799 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48800 PyObject *resultobj = 0;
48801 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48802 int arg2 = (int) 0 ;
48803 int arg3 = (int) 0 ;
48804 void *argp1 = 0 ;
48805 int res1 = 0 ;
48806 int val2 ;
48807 int ecode2 = 0 ;
48808 int val3 ;
48809 int ecode3 = 0 ;
48810 PyObject * obj0 = 0 ;
48811 PyObject * obj1 = 0 ;
48812 PyObject * obj2 = 0 ;
48813 char * kwnames[] = {
48814 (char *) "self",(char *) "row",(char *) "col", NULL
48815 };
48816
48817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48819 if (!SWIG_IsOK(res1)) {
48820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48821 }
48822 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48823 if (obj1) {
48824 ecode2 = SWIG_AsVal_int(obj1, &val2);
48825 if (!SWIG_IsOK(ecode2)) {
48826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48827 }
48828 arg2 = static_cast< int >(val2);
48829 }
48830 if (obj2) {
48831 ecode3 = SWIG_AsVal_int(obj2, &val3);
48832 if (!SWIG_IsOK(ecode3)) {
48833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48834 }
48835 arg3 = static_cast< int >(val3);
48836 }
48837 {
48838 PyThreadState* __tstate = wxPyBeginAllowThreads();
48839 wxGBPosition_Set(arg1,arg2,arg3);
48840 wxPyEndAllowThreads(__tstate);
48841 if (PyErr_Occurred()) SWIG_fail;
48842 }
48843 resultobj = SWIG_Py_Void();
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 PyObject *resultobj = 0;
48852 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48853 PyObject *result = 0 ;
48854 void *argp1 = 0 ;
48855 int res1 = 0 ;
48856 PyObject *swig_obj[1] ;
48857
48858 if (!args) SWIG_fail;
48859 swig_obj[0] = args;
48860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48861 if (!SWIG_IsOK(res1)) {
48862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48863 }
48864 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48865 {
48866 PyThreadState* __tstate = wxPyBeginAllowThreads();
48867 result = (PyObject *)wxGBPosition_Get(arg1);
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 resultobj = result;
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48879 PyObject *obj;
48880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48881 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48882 return SWIG_Py_Void();
48883 }
48884
48885 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48886 return SWIG_Python_InitShadowInstance(args);
48887 }
48888
48889 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48890 PyObject *resultobj = 0;
48891 int arg1 = (int) 1 ;
48892 int arg2 = (int) 1 ;
48893 wxGBSpan *result = 0 ;
48894 int val1 ;
48895 int ecode1 = 0 ;
48896 int val2 ;
48897 int ecode2 = 0 ;
48898 PyObject * obj0 = 0 ;
48899 PyObject * obj1 = 0 ;
48900 char * kwnames[] = {
48901 (char *) "rowspan",(char *) "colspan", NULL
48902 };
48903
48904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48905 if (obj0) {
48906 ecode1 = SWIG_AsVal_int(obj0, &val1);
48907 if (!SWIG_IsOK(ecode1)) {
48908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48909 }
48910 arg1 = static_cast< int >(val1);
48911 }
48912 if (obj1) {
48913 ecode2 = SWIG_AsVal_int(obj1, &val2);
48914 if (!SWIG_IsOK(ecode2)) {
48915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48916 }
48917 arg2 = static_cast< int >(val2);
48918 }
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48935 void *argp1 = 0 ;
48936 int res1 = 0 ;
48937 PyObject *swig_obj[1] ;
48938
48939 if (!args) SWIG_fail;
48940 swig_obj[0] = args;
48941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48942 if (!SWIG_IsOK(res1)) {
48943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48944 }
48945 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48946 {
48947 PyThreadState* __tstate = wxPyBeginAllowThreads();
48948 delete arg1;
48949
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_Py_Void();
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48961 PyObject *resultobj = 0;
48962 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48963 int result;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 PyObject *swig_obj[1] ;
48967
48968 if (!args) SWIG_fail;
48969 swig_obj[0] = args;
48970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48973 }
48974 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48975 {
48976 PyThreadState* __tstate = wxPyBeginAllowThreads();
48977 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 resultobj = SWIG_From_int(static_cast< int >(result));
48982 return resultobj;
48983 fail:
48984 return NULL;
48985 }
48986
48987
48988 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48989 PyObject *resultobj = 0;
48990 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48991 int result;
48992 void *argp1 = 0 ;
48993 int res1 = 0 ;
48994 PyObject *swig_obj[1] ;
48995
48996 if (!args) SWIG_fail;
48997 swig_obj[0] = args;
48998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48999 if (!SWIG_IsOK(res1)) {
49000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49001 }
49002 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49003 {
49004 PyThreadState* __tstate = wxPyBeginAllowThreads();
49005 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49006 wxPyEndAllowThreads(__tstate);
49007 if (PyErr_Occurred()) SWIG_fail;
49008 }
49009 resultobj = SWIG_From_int(static_cast< int >(result));
49010 return resultobj;
49011 fail:
49012 return NULL;
49013 }
49014
49015
49016 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49017 PyObject *resultobj = 0;
49018 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49019 int arg2 ;
49020 void *argp1 = 0 ;
49021 int res1 = 0 ;
49022 int val2 ;
49023 int ecode2 = 0 ;
49024 PyObject * obj0 = 0 ;
49025 PyObject * obj1 = 0 ;
49026 char * kwnames[] = {
49027 (char *) "self",(char *) "rowspan", NULL
49028 };
49029
49030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49032 if (!SWIG_IsOK(res1)) {
49033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49034 }
49035 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49036 ecode2 = SWIG_AsVal_int(obj1, &val2);
49037 if (!SWIG_IsOK(ecode2)) {
49038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49039 }
49040 arg2 = static_cast< int >(val2);
49041 {
49042 PyThreadState* __tstate = wxPyBeginAllowThreads();
49043 (arg1)->SetRowspan(arg2);
49044 wxPyEndAllowThreads(__tstate);
49045 if (PyErr_Occurred()) SWIG_fail;
49046 }
49047 resultobj = SWIG_Py_Void();
49048 return resultobj;
49049 fail:
49050 return NULL;
49051 }
49052
49053
49054 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49055 PyObject *resultobj = 0;
49056 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49057 int arg2 ;
49058 void *argp1 = 0 ;
49059 int res1 = 0 ;
49060 int val2 ;
49061 int ecode2 = 0 ;
49062 PyObject * obj0 = 0 ;
49063 PyObject * obj1 = 0 ;
49064 char * kwnames[] = {
49065 (char *) "self",(char *) "colspan", NULL
49066 };
49067
49068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49070 if (!SWIG_IsOK(res1)) {
49071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49072 }
49073 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49074 ecode2 = SWIG_AsVal_int(obj1, &val2);
49075 if (!SWIG_IsOK(ecode2)) {
49076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49077 }
49078 arg2 = static_cast< int >(val2);
49079 {
49080 PyThreadState* __tstate = wxPyBeginAllowThreads();
49081 (arg1)->SetColspan(arg2);
49082 wxPyEndAllowThreads(__tstate);
49083 if (PyErr_Occurred()) SWIG_fail;
49084 }
49085 resultobj = SWIG_Py_Void();
49086 return resultobj;
49087 fail:
49088 return NULL;
49089 }
49090
49091
49092 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49093 PyObject *resultobj = 0;
49094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49095 PyObject *arg2 = (PyObject *) 0 ;
49096 bool result;
49097 void *argp1 = 0 ;
49098 int res1 = 0 ;
49099 PyObject * obj0 = 0 ;
49100 PyObject * obj1 = 0 ;
49101 char * kwnames[] = {
49102 (char *) "self",(char *) "other", NULL
49103 };
49104
49105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49107 if (!SWIG_IsOK(res1)) {
49108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49109 }
49110 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49111 arg2 = obj1;
49112 {
49113 result = (bool)wxGBSpan___eq__(arg1,arg2);
49114 if (PyErr_Occurred()) SWIG_fail;
49115 }
49116 {
49117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49118 }
49119 return resultobj;
49120 fail:
49121 return NULL;
49122 }
49123
49124
49125 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49126 PyObject *resultobj = 0;
49127 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49128 PyObject *arg2 = (PyObject *) 0 ;
49129 bool result;
49130 void *argp1 = 0 ;
49131 int res1 = 0 ;
49132 PyObject * obj0 = 0 ;
49133 PyObject * obj1 = 0 ;
49134 char * kwnames[] = {
49135 (char *) "self",(char *) "other", NULL
49136 };
49137
49138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49142 }
49143 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49144 arg2 = obj1;
49145 {
49146 result = (bool)wxGBSpan___ne__(arg1,arg2);
49147 if (PyErr_Occurred()) SWIG_fail;
49148 }
49149 {
49150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49151 }
49152 return resultobj;
49153 fail:
49154 return NULL;
49155 }
49156
49157
49158 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49159 PyObject *resultobj = 0;
49160 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49161 int arg2 = (int) 1 ;
49162 int arg3 = (int) 1 ;
49163 void *argp1 = 0 ;
49164 int res1 = 0 ;
49165 int val2 ;
49166 int ecode2 = 0 ;
49167 int val3 ;
49168 int ecode3 = 0 ;
49169 PyObject * obj0 = 0 ;
49170 PyObject * obj1 = 0 ;
49171 PyObject * obj2 = 0 ;
49172 char * kwnames[] = {
49173 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49174 };
49175
49176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49178 if (!SWIG_IsOK(res1)) {
49179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49180 }
49181 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49182 if (obj1) {
49183 ecode2 = SWIG_AsVal_int(obj1, &val2);
49184 if (!SWIG_IsOK(ecode2)) {
49185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49186 }
49187 arg2 = static_cast< int >(val2);
49188 }
49189 if (obj2) {
49190 ecode3 = SWIG_AsVal_int(obj2, &val3);
49191 if (!SWIG_IsOK(ecode3)) {
49192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49193 }
49194 arg3 = static_cast< int >(val3);
49195 }
49196 {
49197 PyThreadState* __tstate = wxPyBeginAllowThreads();
49198 wxGBSpan_Set(arg1,arg2,arg3);
49199 wxPyEndAllowThreads(__tstate);
49200 if (PyErr_Occurred()) SWIG_fail;
49201 }
49202 resultobj = SWIG_Py_Void();
49203 return resultobj;
49204 fail:
49205 return NULL;
49206 }
49207
49208
49209 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49210 PyObject *resultobj = 0;
49211 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49212 PyObject *result = 0 ;
49213 void *argp1 = 0 ;
49214 int res1 = 0 ;
49215 PyObject *swig_obj[1] ;
49216
49217 if (!args) SWIG_fail;
49218 swig_obj[0] = args;
49219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49220 if (!SWIG_IsOK(res1)) {
49221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49222 }
49223 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49224 {
49225 PyThreadState* __tstate = wxPyBeginAllowThreads();
49226 result = (PyObject *)wxGBSpan_Get(arg1);
49227 wxPyEndAllowThreads(__tstate);
49228 if (PyErr_Occurred()) SWIG_fail;
49229 }
49230 resultobj = result;
49231 return resultobj;
49232 fail:
49233 return NULL;
49234 }
49235
49236
49237 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49238 PyObject *obj;
49239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49240 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49241 return SWIG_Py_Void();
49242 }
49243
49244 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49245 return SWIG_Python_InitShadowInstance(args);
49246 }
49247
49248 SWIGINTERN int DefaultSpan_set(PyObject *) {
49249 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49250 return 1;
49251 }
49252
49253
49254 SWIGINTERN PyObject *DefaultSpan_get(void) {
49255 PyObject *pyobj = 0;
49256
49257 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49258 return pyobj;
49259 }
49260
49261
49262 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49263 PyObject *resultobj = 0;
49264 wxGBSizerItem *result = 0 ;
49265
49266 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49267 {
49268 PyThreadState* __tstate = wxPyBeginAllowThreads();
49269 result = (wxGBSizerItem *)new wxGBSizerItem();
49270 wxPyEndAllowThreads(__tstate);
49271 if (PyErr_Occurred()) SWIG_fail;
49272 }
49273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49274 return resultobj;
49275 fail:
49276 return NULL;
49277 }
49278
49279
49280 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49281 PyObject *resultobj = 0;
49282 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49283 void *argp1 = 0 ;
49284 int res1 = 0 ;
49285 PyObject *swig_obj[1] ;
49286
49287 if (!args) SWIG_fail;
49288 swig_obj[0] = args;
49289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49290 if (!SWIG_IsOK(res1)) {
49291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49292 }
49293 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49294 {
49295 PyThreadState* __tstate = wxPyBeginAllowThreads();
49296 delete arg1;
49297
49298 wxPyEndAllowThreads(__tstate);
49299 if (PyErr_Occurred()) SWIG_fail;
49300 }
49301 resultobj = SWIG_Py_Void();
49302 return resultobj;
49303 fail:
49304 return NULL;
49305 }
49306
49307
49308 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49309 PyObject *resultobj = 0;
49310 wxWindow *arg1 = (wxWindow *) 0 ;
49311 wxGBPosition *arg2 = 0 ;
49312 wxGBSpan *arg3 = 0 ;
49313 int arg4 ;
49314 int arg5 ;
49315 PyObject *arg6 = (PyObject *) NULL ;
49316 wxGBSizerItem *result = 0 ;
49317 void *argp1 = 0 ;
49318 int res1 = 0 ;
49319 wxGBPosition temp2 ;
49320 wxGBSpan temp3 ;
49321 int val4 ;
49322 int ecode4 = 0 ;
49323 int val5 ;
49324 int ecode5 = 0 ;
49325 PyObject * obj0 = 0 ;
49326 PyObject * obj1 = 0 ;
49327 PyObject * obj2 = 0 ;
49328 PyObject * obj3 = 0 ;
49329 PyObject * obj4 = 0 ;
49330 PyObject * obj5 = 0 ;
49331 char * kwnames[] = {
49332 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49333 };
49334
49335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49337 if (!SWIG_IsOK(res1)) {
49338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49339 }
49340 arg1 = reinterpret_cast< wxWindow * >(argp1);
49341 {
49342 arg2 = &temp2;
49343 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49344 }
49345 {
49346 arg3 = &temp3;
49347 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49348 }
49349 ecode4 = SWIG_AsVal_int(obj3, &val4);
49350 if (!SWIG_IsOK(ecode4)) {
49351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49352 }
49353 arg4 = static_cast< int >(val4);
49354 ecode5 = SWIG_AsVal_int(obj4, &val5);
49355 if (!SWIG_IsOK(ecode5)) {
49356 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49357 }
49358 arg5 = static_cast< int >(val5);
49359 if (obj5) {
49360 arg6 = obj5;
49361 }
49362 {
49363 PyThreadState* __tstate = wxPyBeginAllowThreads();
49364 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49365 wxPyEndAllowThreads(__tstate);
49366 if (PyErr_Occurred()) SWIG_fail;
49367 }
49368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49369 return resultobj;
49370 fail:
49371 return NULL;
49372 }
49373
49374
49375 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49376 PyObject *resultobj = 0;
49377 wxSizer *arg1 = (wxSizer *) 0 ;
49378 wxGBPosition *arg2 = 0 ;
49379 wxGBSpan *arg3 = 0 ;
49380 int arg4 ;
49381 int arg5 ;
49382 PyObject *arg6 = (PyObject *) NULL ;
49383 wxGBSizerItem *result = 0 ;
49384 int res1 = 0 ;
49385 wxGBPosition temp2 ;
49386 wxGBSpan temp3 ;
49387 int val4 ;
49388 int ecode4 = 0 ;
49389 int val5 ;
49390 int ecode5 = 0 ;
49391 PyObject * obj0 = 0 ;
49392 PyObject * obj1 = 0 ;
49393 PyObject * obj2 = 0 ;
49394 PyObject * obj3 = 0 ;
49395 PyObject * obj4 = 0 ;
49396 PyObject * obj5 = 0 ;
49397 char * kwnames[] = {
49398 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49399 };
49400
49401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49402 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49405 }
49406 {
49407 arg2 = &temp2;
49408 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49409 }
49410 {
49411 arg3 = &temp3;
49412 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49413 }
49414 ecode4 = SWIG_AsVal_int(obj3, &val4);
49415 if (!SWIG_IsOK(ecode4)) {
49416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49417 }
49418 arg4 = static_cast< int >(val4);
49419 ecode5 = SWIG_AsVal_int(obj4, &val5);
49420 if (!SWIG_IsOK(ecode5)) {
49421 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49422 }
49423 arg5 = static_cast< int >(val5);
49424 if (obj5) {
49425 arg6 = obj5;
49426 }
49427 {
49428 PyThreadState* __tstate = wxPyBeginAllowThreads();
49429 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49430 wxPyEndAllowThreads(__tstate);
49431 if (PyErr_Occurred()) SWIG_fail;
49432 }
49433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49434 return resultobj;
49435 fail:
49436 return NULL;
49437 }
49438
49439
49440 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49441 PyObject *resultobj = 0;
49442 int arg1 ;
49443 int arg2 ;
49444 wxGBPosition *arg3 = 0 ;
49445 wxGBSpan *arg4 = 0 ;
49446 int arg5 ;
49447 int arg6 ;
49448 PyObject *arg7 = (PyObject *) NULL ;
49449 wxGBSizerItem *result = 0 ;
49450 int val1 ;
49451 int ecode1 = 0 ;
49452 int val2 ;
49453 int ecode2 = 0 ;
49454 wxGBPosition temp3 ;
49455 wxGBSpan temp4 ;
49456 int val5 ;
49457 int ecode5 = 0 ;
49458 int val6 ;
49459 int ecode6 = 0 ;
49460 PyObject * obj0 = 0 ;
49461 PyObject * obj1 = 0 ;
49462 PyObject * obj2 = 0 ;
49463 PyObject * obj3 = 0 ;
49464 PyObject * obj4 = 0 ;
49465 PyObject * obj5 = 0 ;
49466 PyObject * obj6 = 0 ;
49467 char * kwnames[] = {
49468 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49469 };
49470
49471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49472 ecode1 = SWIG_AsVal_int(obj0, &val1);
49473 if (!SWIG_IsOK(ecode1)) {
49474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49475 }
49476 arg1 = static_cast< int >(val1);
49477 ecode2 = SWIG_AsVal_int(obj1, &val2);
49478 if (!SWIG_IsOK(ecode2)) {
49479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49480 }
49481 arg2 = static_cast< int >(val2);
49482 {
49483 arg3 = &temp3;
49484 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49485 }
49486 {
49487 arg4 = &temp4;
49488 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49489 }
49490 ecode5 = SWIG_AsVal_int(obj4, &val5);
49491 if (!SWIG_IsOK(ecode5)) {
49492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49493 }
49494 arg5 = static_cast< int >(val5);
49495 ecode6 = SWIG_AsVal_int(obj5, &val6);
49496 if (!SWIG_IsOK(ecode6)) {
49497 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49498 }
49499 arg6 = static_cast< int >(val6);
49500 if (obj6) {
49501 arg7 = obj6;
49502 }
49503 {
49504 PyThreadState* __tstate = wxPyBeginAllowThreads();
49505 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49510 return resultobj;
49511 fail:
49512 return NULL;
49513 }
49514
49515
49516 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49517 PyObject *resultobj = 0;
49518 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49519 wxGBPosition result;
49520 void *argp1 = 0 ;
49521 int res1 = 0 ;
49522 PyObject *swig_obj[1] ;
49523
49524 if (!args) SWIG_fail;
49525 swig_obj[0] = args;
49526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49527 if (!SWIG_IsOK(res1)) {
49528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49529 }
49530 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 result = ((wxGBSizerItem const *)arg1)->GetPos();
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49545 PyObject *resultobj = 0;
49546 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49547 wxGBSpan result;
49548 void *argp1 = 0 ;
49549 int res1 = 0 ;
49550 PyObject *swig_obj[1] ;
49551
49552 if (!args) SWIG_fail;
49553 swig_obj[0] = args;
49554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49555 if (!SWIG_IsOK(res1)) {
49556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49557 }
49558 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49559 {
49560 PyThreadState* __tstate = wxPyBeginAllowThreads();
49561 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49562 wxPyEndAllowThreads(__tstate);
49563 if (PyErr_Occurred()) SWIG_fail;
49564 }
49565 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49566 return resultobj;
49567 fail:
49568 return NULL;
49569 }
49570
49571
49572 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49573 PyObject *resultobj = 0;
49574 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49575 wxGBPosition *arg2 = 0 ;
49576 bool result;
49577 void *argp1 = 0 ;
49578 int res1 = 0 ;
49579 wxGBPosition temp2 ;
49580 PyObject * obj0 = 0 ;
49581 PyObject * obj1 = 0 ;
49582 char * kwnames[] = {
49583 (char *) "self",(char *) "pos", NULL
49584 };
49585
49586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49588 if (!SWIG_IsOK(res1)) {
49589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49590 }
49591 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49592 {
49593 arg2 = &temp2;
49594 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49595 }
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 {
49603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49604 }
49605 return resultobj;
49606 fail:
49607 return NULL;
49608 }
49609
49610
49611 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49612 PyObject *resultobj = 0;
49613 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49614 wxGBSpan *arg2 = 0 ;
49615 bool result;
49616 void *argp1 = 0 ;
49617 int res1 = 0 ;
49618 wxGBSpan temp2 ;
49619 PyObject * obj0 = 0 ;
49620 PyObject * obj1 = 0 ;
49621 char * kwnames[] = {
49622 (char *) "self",(char *) "span", NULL
49623 };
49624
49625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49627 if (!SWIG_IsOK(res1)) {
49628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49629 }
49630 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49631 {
49632 arg2 = &temp2;
49633 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49634 }
49635 {
49636 PyThreadState* __tstate = wxPyBeginAllowThreads();
49637 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 {
49642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49643 }
49644 return resultobj;
49645 fail:
49646 return NULL;
49647 }
49648
49649
49650 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49651 PyObject *resultobj = 0;
49652 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49653 wxGBSizerItem *arg2 = 0 ;
49654 bool result;
49655 void *argp1 = 0 ;
49656 int res1 = 0 ;
49657 void *argp2 = 0 ;
49658 int res2 = 0 ;
49659 PyObject * obj0 = 0 ;
49660 PyObject * obj1 = 0 ;
49661 char * kwnames[] = {
49662 (char *) "self",(char *) "other", NULL
49663 };
49664
49665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49667 if (!SWIG_IsOK(res1)) {
49668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49669 }
49670 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49672 if (!SWIG_IsOK(res2)) {
49673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49674 }
49675 if (!argp2) {
49676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49677 }
49678 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49679 {
49680 PyThreadState* __tstate = wxPyBeginAllowThreads();
49681 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49682 wxPyEndAllowThreads(__tstate);
49683 if (PyErr_Occurred()) SWIG_fail;
49684 }
49685 {
49686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49687 }
49688 return resultobj;
49689 fail:
49690 return NULL;
49691 }
49692
49693
49694 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49695 PyObject *resultobj = 0;
49696 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49697 wxGBPosition *arg2 = 0 ;
49698 wxGBSpan *arg3 = 0 ;
49699 bool result;
49700 void *argp1 = 0 ;
49701 int res1 = 0 ;
49702 wxGBPosition temp2 ;
49703 wxGBSpan temp3 ;
49704 PyObject * obj0 = 0 ;
49705 PyObject * obj1 = 0 ;
49706 PyObject * obj2 = 0 ;
49707 char * kwnames[] = {
49708 (char *) "self",(char *) "pos",(char *) "span", NULL
49709 };
49710
49711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49713 if (!SWIG_IsOK(res1)) {
49714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49715 }
49716 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49717 {
49718 arg2 = &temp2;
49719 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49720 }
49721 {
49722 arg3 = &temp3;
49723 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49724 }
49725 {
49726 PyThreadState* __tstate = wxPyBeginAllowThreads();
49727 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49728 wxPyEndAllowThreads(__tstate);
49729 if (PyErr_Occurred()) SWIG_fail;
49730 }
49731 {
49732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49733 }
49734 return resultobj;
49735 fail:
49736 return NULL;
49737 }
49738
49739
49740 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49741 PyObject *resultobj = 0;
49742 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49743 wxGBPosition result;
49744 void *argp1 = 0 ;
49745 int res1 = 0 ;
49746 PyObject *swig_obj[1] ;
49747
49748 if (!args) SWIG_fail;
49749 swig_obj[0] = args;
49750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49751 if (!SWIG_IsOK(res1)) {
49752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49753 }
49754 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49755 {
49756 PyThreadState* __tstate = wxPyBeginAllowThreads();
49757 result = wxGBSizerItem_GetEndPos(arg1);
49758 wxPyEndAllowThreads(__tstate);
49759 if (PyErr_Occurred()) SWIG_fail;
49760 }
49761 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49762 return resultobj;
49763 fail:
49764 return NULL;
49765 }
49766
49767
49768 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49769 PyObject *resultobj = 0;
49770 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49771 wxGridBagSizer *result = 0 ;
49772 void *argp1 = 0 ;
49773 int res1 = 0 ;
49774 PyObject *swig_obj[1] ;
49775
49776 if (!args) SWIG_fail;
49777 swig_obj[0] = args;
49778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49779 if (!SWIG_IsOK(res1)) {
49780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49781 }
49782 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49783 {
49784 PyThreadState* __tstate = wxPyBeginAllowThreads();
49785 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49786 wxPyEndAllowThreads(__tstate);
49787 if (PyErr_Occurred()) SWIG_fail;
49788 }
49789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49790 return resultobj;
49791 fail:
49792 return NULL;
49793 }
49794
49795
49796 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49797 PyObject *resultobj = 0;
49798 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49799 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 void *argp2 = 0 ;
49803 int res2 = 0 ;
49804 PyObject * obj0 = 0 ;
49805 PyObject * obj1 = 0 ;
49806 char * kwnames[] = {
49807 (char *) "self",(char *) "sizer", NULL
49808 };
49809
49810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49812 if (!SWIG_IsOK(res1)) {
49813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49814 }
49815 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49817 if (!SWIG_IsOK(res2)) {
49818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49819 }
49820 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49821 {
49822 PyThreadState* __tstate = wxPyBeginAllowThreads();
49823 (arg1)->SetGBSizer(arg2);
49824 wxPyEndAllowThreads(__tstate);
49825 if (PyErr_Occurred()) SWIG_fail;
49826 }
49827 resultobj = SWIG_Py_Void();
49828 return resultobj;
49829 fail:
49830 return NULL;
49831 }
49832
49833
49834 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49835 PyObject *obj;
49836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49837 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49838 return SWIG_Py_Void();
49839 }
49840
49841 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49842 return SWIG_Python_InitShadowInstance(args);
49843 }
49844
49845 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49846 PyObject *resultobj = 0;
49847 int arg1 = (int) 0 ;
49848 int arg2 = (int) 0 ;
49849 wxGridBagSizer *result = 0 ;
49850 int val1 ;
49851 int ecode1 = 0 ;
49852 int val2 ;
49853 int ecode2 = 0 ;
49854 PyObject * obj0 = 0 ;
49855 PyObject * obj1 = 0 ;
49856 char * kwnames[] = {
49857 (char *) "vgap",(char *) "hgap", NULL
49858 };
49859
49860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49861 if (obj0) {
49862 ecode1 = SWIG_AsVal_int(obj0, &val1);
49863 if (!SWIG_IsOK(ecode1)) {
49864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49865 }
49866 arg1 = static_cast< int >(val1);
49867 }
49868 if (obj1) {
49869 ecode2 = SWIG_AsVal_int(obj1, &val2);
49870 if (!SWIG_IsOK(ecode2)) {
49871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49872 }
49873 arg2 = static_cast< int >(val2);
49874 }
49875 {
49876 PyThreadState* __tstate = wxPyBeginAllowThreads();
49877 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49878 wxPyEndAllowThreads(__tstate);
49879 if (PyErr_Occurred()) SWIG_fail;
49880 }
49881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49882 return resultobj;
49883 fail:
49884 return NULL;
49885 }
49886
49887
49888 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49889 PyObject *resultobj = 0;
49890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49891 PyObject *arg2 = (PyObject *) 0 ;
49892 wxGBPosition *arg3 = 0 ;
49893 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49894 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49895 int arg5 = (int) 0 ;
49896 int arg6 = (int) 0 ;
49897 PyObject *arg7 = (PyObject *) NULL ;
49898 wxGBSizerItem *result = 0 ;
49899 void *argp1 = 0 ;
49900 int res1 = 0 ;
49901 wxGBPosition temp3 ;
49902 wxGBSpan temp4 ;
49903 int val5 ;
49904 int ecode5 = 0 ;
49905 int val6 ;
49906 int ecode6 = 0 ;
49907 PyObject * obj0 = 0 ;
49908 PyObject * obj1 = 0 ;
49909 PyObject * obj2 = 0 ;
49910 PyObject * obj3 = 0 ;
49911 PyObject * obj4 = 0 ;
49912 PyObject * obj5 = 0 ;
49913 PyObject * obj6 = 0 ;
49914 char * kwnames[] = {
49915 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49916 };
49917
49918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49922 }
49923 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49924 arg2 = obj1;
49925 {
49926 arg3 = &temp3;
49927 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49928 }
49929 if (obj3) {
49930 {
49931 arg4 = &temp4;
49932 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49933 }
49934 }
49935 if (obj4) {
49936 ecode5 = SWIG_AsVal_int(obj4, &val5);
49937 if (!SWIG_IsOK(ecode5)) {
49938 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49939 }
49940 arg5 = static_cast< int >(val5);
49941 }
49942 if (obj5) {
49943 ecode6 = SWIG_AsVal_int(obj5, &val6);
49944 if (!SWIG_IsOK(ecode6)) {
49945 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49946 }
49947 arg6 = static_cast< int >(val6);
49948 }
49949 if (obj6) {
49950 arg7 = obj6;
49951 }
49952 {
49953 PyThreadState* __tstate = wxPyBeginAllowThreads();
49954 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49955 wxPyEndAllowThreads(__tstate);
49956 if (PyErr_Occurred()) SWIG_fail;
49957 }
49958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49959 return resultobj;
49960 fail:
49961 return NULL;
49962 }
49963
49964
49965 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49966 PyObject *resultobj = 0;
49967 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49968 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49969 wxGBSizerItem *result = 0 ;
49970 void *argp1 = 0 ;
49971 int res1 = 0 ;
49972 int res2 = 0 ;
49973 PyObject * obj0 = 0 ;
49974 PyObject * obj1 = 0 ;
49975 char * kwnames[] = {
49976 (char *) "self",(char *) "item", NULL
49977 };
49978
49979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49981 if (!SWIG_IsOK(res1)) {
49982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49983 }
49984 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49985 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49986 if (!SWIG_IsOK(res2)) {
49987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49988 }
49989 {
49990 PyThreadState* __tstate = wxPyBeginAllowThreads();
49991 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49992 wxPyEndAllowThreads(__tstate);
49993 if (PyErr_Occurred()) SWIG_fail;
49994 }
49995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49996 return resultobj;
49997 fail:
49998 return NULL;
49999 }
50000
50001
50002 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50003 PyObject *resultobj = 0;
50004 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50005 int arg2 ;
50006 int arg3 ;
50007 wxSize result;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 int val2 ;
50011 int ecode2 = 0 ;
50012 int val3 ;
50013 int ecode3 = 0 ;
50014 PyObject * obj0 = 0 ;
50015 PyObject * obj1 = 0 ;
50016 PyObject * obj2 = 0 ;
50017 char * kwnames[] = {
50018 (char *) "self",(char *) "row",(char *) "col", NULL
50019 };
50020
50021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50025 }
50026 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50027 ecode2 = SWIG_AsVal_int(obj1, &val2);
50028 if (!SWIG_IsOK(ecode2)) {
50029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50030 }
50031 arg2 = static_cast< int >(val2);
50032 ecode3 = SWIG_AsVal_int(obj2, &val3);
50033 if (!SWIG_IsOK(ecode3)) {
50034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50035 }
50036 arg3 = static_cast< int >(val3);
50037 {
50038 PyThreadState* __tstate = wxPyBeginAllowThreads();
50039 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50040 wxPyEndAllowThreads(__tstate);
50041 if (PyErr_Occurred()) SWIG_fail;
50042 }
50043 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50044 return resultobj;
50045 fail:
50046 return NULL;
50047 }
50048
50049
50050 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50051 PyObject *resultobj = 0;
50052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50053 wxSize result;
50054 void *argp1 = 0 ;
50055 int res1 = 0 ;
50056 PyObject *swig_obj[1] ;
50057
50058 if (!args) SWIG_fail;
50059 swig_obj[0] = args;
50060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50061 if (!SWIG_IsOK(res1)) {
50062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50063 }
50064 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50065 {
50066 PyThreadState* __tstate = wxPyBeginAllowThreads();
50067 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50068 wxPyEndAllowThreads(__tstate);
50069 if (PyErr_Occurred()) SWIG_fail;
50070 }
50071 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50072 return resultobj;
50073 fail:
50074 return NULL;
50075 }
50076
50077
50078 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50079 PyObject *resultobj = 0;
50080 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50081 wxSize *arg2 = 0 ;
50082 void *argp1 = 0 ;
50083 int res1 = 0 ;
50084 wxSize temp2 ;
50085 PyObject * obj0 = 0 ;
50086 PyObject * obj1 = 0 ;
50087 char * kwnames[] = {
50088 (char *) "self",(char *) "sz", NULL
50089 };
50090
50091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50093 if (!SWIG_IsOK(res1)) {
50094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50095 }
50096 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50097 {
50098 arg2 = &temp2;
50099 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50100 }
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_Py_Void();
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50115 PyObject *resultobj = 0;
50116 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50117 wxWindow *arg2 = (wxWindow *) 0 ;
50118 wxGBPosition result;
50119 void *argp1 = 0 ;
50120 int res1 = 0 ;
50121 void *argp2 = 0 ;
50122 int res2 = 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 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50131 if (!SWIG_IsOK(res2)) {
50132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50133 }
50134 arg2 = reinterpret_cast< wxWindow * >(argp2);
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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50149 PyObject *resultobj = 0;
50150 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50151 wxSizer *arg2 = (wxSizer *) 0 ;
50152 wxGBPosition result;
50153 void *argp1 = 0 ;
50154 int res1 = 0 ;
50155 void *argp2 = 0 ;
50156 int res2 = 0 ;
50157
50158 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50160 if (!SWIG_IsOK(res1)) {
50161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50162 }
50163 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50164 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50165 if (!SWIG_IsOK(res2)) {
50166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50167 }
50168 arg2 = reinterpret_cast< wxSizer * >(argp2);
50169 {
50170 PyThreadState* __tstate = wxPyBeginAllowThreads();
50171 result = (arg1)->GetItemPosition(arg2);
50172 wxPyEndAllowThreads(__tstate);
50173 if (PyErr_Occurred()) SWIG_fail;
50174 }
50175 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50176 return resultobj;
50177 fail:
50178 return NULL;
50179 }
50180
50181
50182 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50183 PyObject *resultobj = 0;
50184 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50185 size_t arg2 ;
50186 wxGBPosition result;
50187 void *argp1 = 0 ;
50188 int res1 = 0 ;
50189 size_t val2 ;
50190 int ecode2 = 0 ;
50191
50192 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50194 if (!SWIG_IsOK(res1)) {
50195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50196 }
50197 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50198 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50199 if (!SWIG_IsOK(ecode2)) {
50200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50201 }
50202 arg2 = static_cast< size_t >(val2);
50203 {
50204 PyThreadState* __tstate = wxPyBeginAllowThreads();
50205 result = (arg1)->GetItemPosition(arg2);
50206 wxPyEndAllowThreads(__tstate);
50207 if (PyErr_Occurred()) SWIG_fail;
50208 }
50209 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50210 return resultobj;
50211 fail:
50212 return NULL;
50213 }
50214
50215
50216 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50217 int argc;
50218 PyObject *argv[3];
50219
50220 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50221 --argc;
50222 if (argc == 2) {
50223 int _v = 0;
50224 {
50225 void *vptr = 0;
50226 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50227 _v = SWIG_CheckState(res);
50228 }
50229 if (!_v) goto check_1;
50230 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50231 }
50232 check_1:
50233
50234 if (argc == 2) {
50235 int _v = 0;
50236 {
50237 void *vptr = 0;
50238 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50239 _v = SWIG_CheckState(res);
50240 }
50241 if (!_v) goto check_2;
50242 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50243 }
50244 check_2:
50245
50246 if (argc == 2) {
50247 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50248 }
50249
50250 fail:
50251 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50252 return NULL;
50253 }
50254
50255
50256 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50257 PyObject *resultobj = 0;
50258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50259 wxWindow *arg2 = (wxWindow *) 0 ;
50260 wxGBPosition *arg3 = 0 ;
50261 bool result;
50262 void *argp1 = 0 ;
50263 int res1 = 0 ;
50264 void *argp2 = 0 ;
50265 int res2 = 0 ;
50266 wxGBPosition temp3 ;
50267
50268 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50272 }
50273 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50274 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50275 if (!SWIG_IsOK(res2)) {
50276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50277 }
50278 arg2 = reinterpret_cast< wxWindow * >(argp2);
50279 {
50280 arg3 = &temp3;
50281 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50282 }
50283 {
50284 PyThreadState* __tstate = wxPyBeginAllowThreads();
50285 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50286 wxPyEndAllowThreads(__tstate);
50287 if (PyErr_Occurred()) SWIG_fail;
50288 }
50289 {
50290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50291 }
50292 return resultobj;
50293 fail:
50294 return NULL;
50295 }
50296
50297
50298 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50299 PyObject *resultobj = 0;
50300 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50301 wxSizer *arg2 = (wxSizer *) 0 ;
50302 wxGBPosition *arg3 = 0 ;
50303 bool result;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 void *argp2 = 0 ;
50307 int res2 = 0 ;
50308 wxGBPosition temp3 ;
50309
50310 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50312 if (!SWIG_IsOK(res1)) {
50313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50314 }
50315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50316 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50317 if (!SWIG_IsOK(res2)) {
50318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50319 }
50320 arg2 = reinterpret_cast< wxSizer * >(argp2);
50321 {
50322 arg3 = &temp3;
50323 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50324 }
50325 {
50326 PyThreadState* __tstate = wxPyBeginAllowThreads();
50327 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50328 wxPyEndAllowThreads(__tstate);
50329 if (PyErr_Occurred()) SWIG_fail;
50330 }
50331 {
50332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50333 }
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50341 PyObject *resultobj = 0;
50342 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50343 size_t arg2 ;
50344 wxGBPosition *arg3 = 0 ;
50345 bool result;
50346 void *argp1 = 0 ;
50347 int res1 = 0 ;
50348 size_t val2 ;
50349 int ecode2 = 0 ;
50350 wxGBPosition temp3 ;
50351
50352 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50354 if (!SWIG_IsOK(res1)) {
50355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50356 }
50357 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50358 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50359 if (!SWIG_IsOK(ecode2)) {
50360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50361 }
50362 arg2 = static_cast< size_t >(val2);
50363 {
50364 arg3 = &temp3;
50365 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50366 }
50367 {
50368 PyThreadState* __tstate = wxPyBeginAllowThreads();
50369 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50370 wxPyEndAllowThreads(__tstate);
50371 if (PyErr_Occurred()) SWIG_fail;
50372 }
50373 {
50374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50375 }
50376 return resultobj;
50377 fail:
50378 return NULL;
50379 }
50380
50381
50382 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50383 int argc;
50384 PyObject *argv[4];
50385
50386 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50387 --argc;
50388 if (argc == 3) {
50389 int _v = 0;
50390 {
50391 void *vptr = 0;
50392 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50393 _v = SWIG_CheckState(res);
50394 }
50395 if (!_v) goto check_1;
50396 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50397 }
50398 check_1:
50399
50400 if (argc == 3) {
50401 int _v = 0;
50402 {
50403 void *vptr = 0;
50404 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50405 _v = SWIG_CheckState(res);
50406 }
50407 if (!_v) goto check_2;
50408 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50409 }
50410 check_2:
50411
50412 if (argc == 3) {
50413 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50414 }
50415
50416 fail:
50417 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50423 PyObject *resultobj = 0;
50424 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50425 wxWindow *arg2 = (wxWindow *) 0 ;
50426 wxGBSpan result;
50427 void *argp1 = 0 ;
50428 int res1 = 0 ;
50429 void *argp2 = 0 ;
50430 int res2 = 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 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50439 if (!SWIG_IsOK(res2)) {
50440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50441 }
50442 arg2 = reinterpret_cast< wxWindow * >(argp2);
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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50457 PyObject *resultobj = 0;
50458 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50459 wxSizer *arg2 = (wxSizer *) 0 ;
50460 wxGBSpan result;
50461 void *argp1 = 0 ;
50462 int res1 = 0 ;
50463 void *argp2 = 0 ;
50464 int res2 = 0 ;
50465
50466 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50468 if (!SWIG_IsOK(res1)) {
50469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50470 }
50471 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50472 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50473 if (!SWIG_IsOK(res2)) {
50474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50475 }
50476 arg2 = reinterpret_cast< wxSizer * >(argp2);
50477 {
50478 PyThreadState* __tstate = wxPyBeginAllowThreads();
50479 result = (arg1)->GetItemSpan(arg2);
50480 wxPyEndAllowThreads(__tstate);
50481 if (PyErr_Occurred()) SWIG_fail;
50482 }
50483 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50484 return resultobj;
50485 fail:
50486 return NULL;
50487 }
50488
50489
50490 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50491 PyObject *resultobj = 0;
50492 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50493 size_t arg2 ;
50494 wxGBSpan result;
50495 void *argp1 = 0 ;
50496 int res1 = 0 ;
50497 size_t val2 ;
50498 int ecode2 = 0 ;
50499
50500 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50502 if (!SWIG_IsOK(res1)) {
50503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50504 }
50505 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50506 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50507 if (!SWIG_IsOK(ecode2)) {
50508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50509 }
50510 arg2 = static_cast< size_t >(val2);
50511 {
50512 PyThreadState* __tstate = wxPyBeginAllowThreads();
50513 result = (arg1)->GetItemSpan(arg2);
50514 wxPyEndAllowThreads(__tstate);
50515 if (PyErr_Occurred()) SWIG_fail;
50516 }
50517 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50518 return resultobj;
50519 fail:
50520 return NULL;
50521 }
50522
50523
50524 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50525 int argc;
50526 PyObject *argv[3];
50527
50528 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50529 --argc;
50530 if (argc == 2) {
50531 int _v = 0;
50532 {
50533 void *vptr = 0;
50534 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50535 _v = SWIG_CheckState(res);
50536 }
50537 if (!_v) goto check_1;
50538 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50539 }
50540 check_1:
50541
50542 if (argc == 2) {
50543 int _v = 0;
50544 {
50545 void *vptr = 0;
50546 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50547 _v = SWIG_CheckState(res);
50548 }
50549 if (!_v) goto check_2;
50550 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50551 }
50552 check_2:
50553
50554 if (argc == 2) {
50555 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50556 }
50557
50558 fail:
50559 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50565 PyObject *resultobj = 0;
50566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50567 wxWindow *arg2 = (wxWindow *) 0 ;
50568 wxGBSpan *arg3 = 0 ;
50569 bool result;
50570 void *argp1 = 0 ;
50571 int res1 = 0 ;
50572 void *argp2 = 0 ;
50573 int res2 = 0 ;
50574 wxGBSpan temp3 ;
50575
50576 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50578 if (!SWIG_IsOK(res1)) {
50579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50580 }
50581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50583 if (!SWIG_IsOK(res2)) {
50584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50585 }
50586 arg2 = reinterpret_cast< wxWindow * >(argp2);
50587 {
50588 arg3 = &temp3;
50589 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50590 }
50591 {
50592 PyThreadState* __tstate = wxPyBeginAllowThreads();
50593 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50594 wxPyEndAllowThreads(__tstate);
50595 if (PyErr_Occurred()) SWIG_fail;
50596 }
50597 {
50598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50599 }
50600 return resultobj;
50601 fail:
50602 return NULL;
50603 }
50604
50605
50606 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50607 PyObject *resultobj = 0;
50608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50609 wxSizer *arg2 = (wxSizer *) 0 ;
50610 wxGBSpan *arg3 = 0 ;
50611 bool result;
50612 void *argp1 = 0 ;
50613 int res1 = 0 ;
50614 void *argp2 = 0 ;
50615 int res2 = 0 ;
50616 wxGBSpan temp3 ;
50617
50618 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50620 if (!SWIG_IsOK(res1)) {
50621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50622 }
50623 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50624 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50625 if (!SWIG_IsOK(res2)) {
50626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50627 }
50628 arg2 = reinterpret_cast< wxSizer * >(argp2);
50629 {
50630 arg3 = &temp3;
50631 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50632 }
50633 {
50634 PyThreadState* __tstate = wxPyBeginAllowThreads();
50635 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 {
50640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50641 }
50642 return resultobj;
50643 fail:
50644 return NULL;
50645 }
50646
50647
50648 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50649 PyObject *resultobj = 0;
50650 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50651 size_t arg2 ;
50652 wxGBSpan *arg3 = 0 ;
50653 bool result;
50654 void *argp1 = 0 ;
50655 int res1 = 0 ;
50656 size_t val2 ;
50657 int ecode2 = 0 ;
50658 wxGBSpan temp3 ;
50659
50660 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50662 if (!SWIG_IsOK(res1)) {
50663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50664 }
50665 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50666 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50667 if (!SWIG_IsOK(ecode2)) {
50668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50669 }
50670 arg2 = static_cast< size_t >(val2);
50671 {
50672 arg3 = &temp3;
50673 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50674 }
50675 {
50676 PyThreadState* __tstate = wxPyBeginAllowThreads();
50677 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50678 wxPyEndAllowThreads(__tstate);
50679 if (PyErr_Occurred()) SWIG_fail;
50680 }
50681 {
50682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50683 }
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50691 int argc;
50692 PyObject *argv[4];
50693
50694 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50695 --argc;
50696 if (argc == 3) {
50697 int _v = 0;
50698 {
50699 void *vptr = 0;
50700 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50701 _v = SWIG_CheckState(res);
50702 }
50703 if (!_v) goto check_1;
50704 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50705 }
50706 check_1:
50707
50708 if (argc == 3) {
50709 int _v = 0;
50710 {
50711 void *vptr = 0;
50712 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50713 _v = SWIG_CheckState(res);
50714 }
50715 if (!_v) goto check_2;
50716 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50717 }
50718 check_2:
50719
50720 if (argc == 3) {
50721 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50722 }
50723
50724 fail:
50725 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50726 return NULL;
50727 }
50728
50729
50730 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50731 PyObject *resultobj = 0;
50732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50733 wxWindow *arg2 = (wxWindow *) 0 ;
50734 wxGBSizerItem *result = 0 ;
50735 void *argp1 = 0 ;
50736 int res1 = 0 ;
50737 void *argp2 = 0 ;
50738 int res2 = 0 ;
50739
50740 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50742 if (!SWIG_IsOK(res1)) {
50743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50744 }
50745 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50746 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50747 if (!SWIG_IsOK(res2)) {
50748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50749 }
50750 arg2 = reinterpret_cast< wxWindow * >(argp2);
50751 {
50752 PyThreadState* __tstate = wxPyBeginAllowThreads();
50753 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50754 wxPyEndAllowThreads(__tstate);
50755 if (PyErr_Occurred()) SWIG_fail;
50756 }
50757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50758 return resultobj;
50759 fail:
50760 return NULL;
50761 }
50762
50763
50764 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50765 PyObject *resultobj = 0;
50766 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50767 wxSizer *arg2 = (wxSizer *) 0 ;
50768 wxGBSizerItem *result = 0 ;
50769 void *argp1 = 0 ;
50770 int res1 = 0 ;
50771 void *argp2 = 0 ;
50772 int res2 = 0 ;
50773
50774 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50776 if (!SWIG_IsOK(res1)) {
50777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50778 }
50779 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50780 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res2)) {
50782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50783 }
50784 arg2 = reinterpret_cast< wxSizer * >(argp2);
50785 {
50786 PyThreadState* __tstate = wxPyBeginAllowThreads();
50787 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50788 wxPyEndAllowThreads(__tstate);
50789 if (PyErr_Occurred()) SWIG_fail;
50790 }
50791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50792 return resultobj;
50793 fail:
50794 return NULL;
50795 }
50796
50797
50798 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50799 int argc;
50800 PyObject *argv[3];
50801
50802 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50803 --argc;
50804 if (argc == 2) {
50805 int _v = 0;
50806 {
50807 void *vptr = 0;
50808 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50809 _v = SWIG_CheckState(res);
50810 }
50811 if (!_v) goto check_1;
50812 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50813 }
50814 check_1:
50815
50816 if (argc == 2) {
50817 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50818 }
50819
50820 fail:
50821 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50822 return NULL;
50823 }
50824
50825
50826 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50827 PyObject *resultobj = 0;
50828 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50829 wxGBPosition *arg2 = 0 ;
50830 wxGBSizerItem *result = 0 ;
50831 void *argp1 = 0 ;
50832 int res1 = 0 ;
50833 wxGBPosition temp2 ;
50834 PyObject * obj0 = 0 ;
50835 PyObject * obj1 = 0 ;
50836 char * kwnames[] = {
50837 (char *) "self",(char *) "pos", NULL
50838 };
50839
50840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50842 if (!SWIG_IsOK(res1)) {
50843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50844 }
50845 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50846 {
50847 arg2 = &temp2;
50848 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50849 }
50850 {
50851 PyThreadState* __tstate = wxPyBeginAllowThreads();
50852 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50853 wxPyEndAllowThreads(__tstate);
50854 if (PyErr_Occurred()) SWIG_fail;
50855 }
50856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50857 return resultobj;
50858 fail:
50859 return NULL;
50860 }
50861
50862
50863 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50864 PyObject *resultobj = 0;
50865 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50866 wxPoint *arg2 = 0 ;
50867 wxGBSizerItem *result = 0 ;
50868 void *argp1 = 0 ;
50869 int res1 = 0 ;
50870 wxPoint temp2 ;
50871 PyObject * obj0 = 0 ;
50872 PyObject * obj1 = 0 ;
50873 char * kwnames[] = {
50874 (char *) "self",(char *) "pt", NULL
50875 };
50876
50877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50879 if (!SWIG_IsOK(res1)) {
50880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50881 }
50882 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50883 {
50884 arg2 = &temp2;
50885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50886 }
50887 {
50888 PyThreadState* __tstate = wxPyBeginAllowThreads();
50889 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50890 wxPyEndAllowThreads(__tstate);
50891 if (PyErr_Occurred()) SWIG_fail;
50892 }
50893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50894 return resultobj;
50895 fail:
50896 return NULL;
50897 }
50898
50899
50900 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50901 PyObject *resultobj = 0;
50902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50903 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50904 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50905 bool result;
50906 void *argp1 = 0 ;
50907 int res1 = 0 ;
50908 void *argp2 = 0 ;
50909 int res2 = 0 ;
50910 void *argp3 = 0 ;
50911 int res3 = 0 ;
50912 PyObject * obj0 = 0 ;
50913 PyObject * obj1 = 0 ;
50914 PyObject * obj2 = 0 ;
50915 char * kwnames[] = {
50916 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50917 };
50918
50919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50921 if (!SWIG_IsOK(res1)) {
50922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50923 }
50924 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50926 if (!SWIG_IsOK(res2)) {
50927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50928 }
50929 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50930 if (obj2) {
50931 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50932 if (!SWIG_IsOK(res3)) {
50933 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50934 }
50935 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50936 }
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 {
50944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50945 }
50946 return resultobj;
50947 fail:
50948 return NULL;
50949 }
50950
50951
50952 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50953 PyObject *resultobj = 0;
50954 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50955 wxGBPosition *arg2 = 0 ;
50956 wxGBSpan *arg3 = 0 ;
50957 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50958 bool result;
50959 void *argp1 = 0 ;
50960 int res1 = 0 ;
50961 wxGBPosition temp2 ;
50962 wxGBSpan temp3 ;
50963 void *argp4 = 0 ;
50964 int res4 = 0 ;
50965 PyObject * obj0 = 0 ;
50966 PyObject * obj1 = 0 ;
50967 PyObject * obj2 = 0 ;
50968 PyObject * obj3 = 0 ;
50969 char * kwnames[] = {
50970 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50971 };
50972
50973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50975 if (!SWIG_IsOK(res1)) {
50976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50977 }
50978 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50979 {
50980 arg2 = &temp2;
50981 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50982 }
50983 {
50984 arg3 = &temp3;
50985 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50986 }
50987 if (obj3) {
50988 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50989 if (!SWIG_IsOK(res4)) {
50990 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50991 }
50992 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50993 }
50994 {
50995 PyThreadState* __tstate = wxPyBeginAllowThreads();
50996 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50997 wxPyEndAllowThreads(__tstate);
50998 if (PyErr_Occurred()) SWIG_fail;
50999 }
51000 {
51001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51002 }
51003 return resultobj;
51004 fail:
51005 return NULL;
51006 }
51007
51008
51009 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51010 PyObject *obj;
51011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51012 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51013 return SWIG_Py_Void();
51014 }
51015
51016 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51017 return SWIG_Python_InitShadowInstance(args);
51018 }
51019
51020 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51021 PyObject *resultobj = 0;
51022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51023 wxRelationship arg2 ;
51024 wxWindow *arg3 = (wxWindow *) 0 ;
51025 wxEdge arg4 ;
51026 int arg5 = (int) 0 ;
51027 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51028 void *argp1 = 0 ;
51029 int res1 = 0 ;
51030 int val2 ;
51031 int ecode2 = 0 ;
51032 void *argp3 = 0 ;
51033 int res3 = 0 ;
51034 int val4 ;
51035 int ecode4 = 0 ;
51036 int val5 ;
51037 int ecode5 = 0 ;
51038 int val6 ;
51039 int ecode6 = 0 ;
51040 PyObject * obj0 = 0 ;
51041 PyObject * obj1 = 0 ;
51042 PyObject * obj2 = 0 ;
51043 PyObject * obj3 = 0 ;
51044 PyObject * obj4 = 0 ;
51045 PyObject * obj5 = 0 ;
51046 char * kwnames[] = {
51047 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51048 };
51049
51050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51052 if (!SWIG_IsOK(res1)) {
51053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51054 }
51055 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51056 ecode2 = SWIG_AsVal_int(obj1, &val2);
51057 if (!SWIG_IsOK(ecode2)) {
51058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51059 }
51060 arg2 = static_cast< wxRelationship >(val2);
51061 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51062 if (!SWIG_IsOK(res3)) {
51063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51064 }
51065 arg3 = reinterpret_cast< wxWindow * >(argp3);
51066 ecode4 = SWIG_AsVal_int(obj3, &val4);
51067 if (!SWIG_IsOK(ecode4)) {
51068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51069 }
51070 arg4 = static_cast< wxEdge >(val4);
51071 if (obj4) {
51072 ecode5 = SWIG_AsVal_int(obj4, &val5);
51073 if (!SWIG_IsOK(ecode5)) {
51074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51075 }
51076 arg5 = static_cast< int >(val5);
51077 }
51078 if (obj5) {
51079 ecode6 = SWIG_AsVal_int(obj5, &val6);
51080 if (!SWIG_IsOK(ecode6)) {
51081 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51082 }
51083 arg6 = static_cast< int >(val6);
51084 }
51085 {
51086 PyThreadState* __tstate = wxPyBeginAllowThreads();
51087 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51088 wxPyEndAllowThreads(__tstate);
51089 if (PyErr_Occurred()) SWIG_fail;
51090 }
51091 resultobj = SWIG_Py_Void();
51092 return resultobj;
51093 fail:
51094 return NULL;
51095 }
51096
51097
51098 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51099 PyObject *resultobj = 0;
51100 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51101 wxWindow *arg2 = (wxWindow *) 0 ;
51102 int arg3 = (int) 0 ;
51103 void *argp1 = 0 ;
51104 int res1 = 0 ;
51105 void *argp2 = 0 ;
51106 int res2 = 0 ;
51107 int val3 ;
51108 int ecode3 = 0 ;
51109 PyObject * obj0 = 0 ;
51110 PyObject * obj1 = 0 ;
51111 PyObject * obj2 = 0 ;
51112 char * kwnames[] = {
51113 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51114 };
51115
51116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51118 if (!SWIG_IsOK(res1)) {
51119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51120 }
51121 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51123 if (!SWIG_IsOK(res2)) {
51124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51125 }
51126 arg2 = reinterpret_cast< wxWindow * >(argp2);
51127 if (obj2) {
51128 ecode3 = SWIG_AsVal_int(obj2, &val3);
51129 if (!SWIG_IsOK(ecode3)) {
51130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51131 }
51132 arg3 = static_cast< int >(val3);
51133 }
51134 {
51135 PyThreadState* __tstate = wxPyBeginAllowThreads();
51136 (arg1)->LeftOf(arg2,arg3);
51137 wxPyEndAllowThreads(__tstate);
51138 if (PyErr_Occurred()) SWIG_fail;
51139 }
51140 resultobj = SWIG_Py_Void();
51141 return resultobj;
51142 fail:
51143 return NULL;
51144 }
51145
51146
51147 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51148 PyObject *resultobj = 0;
51149 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51150 wxWindow *arg2 = (wxWindow *) 0 ;
51151 int arg3 = (int) 0 ;
51152 void *argp1 = 0 ;
51153 int res1 = 0 ;
51154 void *argp2 = 0 ;
51155 int res2 = 0 ;
51156 int val3 ;
51157 int ecode3 = 0 ;
51158 PyObject * obj0 = 0 ;
51159 PyObject * obj1 = 0 ;
51160 PyObject * obj2 = 0 ;
51161 char * kwnames[] = {
51162 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51163 };
51164
51165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51167 if (!SWIG_IsOK(res1)) {
51168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51169 }
51170 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51172 if (!SWIG_IsOK(res2)) {
51173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51174 }
51175 arg2 = reinterpret_cast< wxWindow * >(argp2);
51176 if (obj2) {
51177 ecode3 = SWIG_AsVal_int(obj2, &val3);
51178 if (!SWIG_IsOK(ecode3)) {
51179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51180 }
51181 arg3 = static_cast< int >(val3);
51182 }
51183 {
51184 PyThreadState* __tstate = wxPyBeginAllowThreads();
51185 (arg1)->RightOf(arg2,arg3);
51186 wxPyEndAllowThreads(__tstate);
51187 if (PyErr_Occurred()) SWIG_fail;
51188 }
51189 resultobj = SWIG_Py_Void();
51190 return resultobj;
51191 fail:
51192 return NULL;
51193 }
51194
51195
51196 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51197 PyObject *resultobj = 0;
51198 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51199 wxWindow *arg2 = (wxWindow *) 0 ;
51200 int arg3 = (int) 0 ;
51201 void *argp1 = 0 ;
51202 int res1 = 0 ;
51203 void *argp2 = 0 ;
51204 int res2 = 0 ;
51205 int val3 ;
51206 int ecode3 = 0 ;
51207 PyObject * obj0 = 0 ;
51208 PyObject * obj1 = 0 ;
51209 PyObject * obj2 = 0 ;
51210 char * kwnames[] = {
51211 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51212 };
51213
51214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51216 if (!SWIG_IsOK(res1)) {
51217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51218 }
51219 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51221 if (!SWIG_IsOK(res2)) {
51222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51223 }
51224 arg2 = reinterpret_cast< wxWindow * >(argp2);
51225 if (obj2) {
51226 ecode3 = SWIG_AsVal_int(obj2, &val3);
51227 if (!SWIG_IsOK(ecode3)) {
51228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51229 }
51230 arg3 = static_cast< int >(val3);
51231 }
51232 {
51233 PyThreadState* __tstate = wxPyBeginAllowThreads();
51234 (arg1)->Above(arg2,arg3);
51235 wxPyEndAllowThreads(__tstate);
51236 if (PyErr_Occurred()) SWIG_fail;
51237 }
51238 resultobj = SWIG_Py_Void();
51239 return resultobj;
51240 fail:
51241 return NULL;
51242 }
51243
51244
51245 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51246 PyObject *resultobj = 0;
51247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51248 wxWindow *arg2 = (wxWindow *) 0 ;
51249 int arg3 = (int) 0 ;
51250 void *argp1 = 0 ;
51251 int res1 = 0 ;
51252 void *argp2 = 0 ;
51253 int res2 = 0 ;
51254 int val3 ;
51255 int ecode3 = 0 ;
51256 PyObject * obj0 = 0 ;
51257 PyObject * obj1 = 0 ;
51258 PyObject * obj2 = 0 ;
51259 char * kwnames[] = {
51260 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51261 };
51262
51263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51265 if (!SWIG_IsOK(res1)) {
51266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51267 }
51268 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51270 if (!SWIG_IsOK(res2)) {
51271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51272 }
51273 arg2 = reinterpret_cast< wxWindow * >(argp2);
51274 if (obj2) {
51275 ecode3 = SWIG_AsVal_int(obj2, &val3);
51276 if (!SWIG_IsOK(ecode3)) {
51277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51278 }
51279 arg3 = static_cast< int >(val3);
51280 }
51281 {
51282 PyThreadState* __tstate = wxPyBeginAllowThreads();
51283 (arg1)->Below(arg2,arg3);
51284 wxPyEndAllowThreads(__tstate);
51285 if (PyErr_Occurred()) SWIG_fail;
51286 }
51287 resultobj = SWIG_Py_Void();
51288 return resultobj;
51289 fail:
51290 return NULL;
51291 }
51292
51293
51294 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51295 PyObject *resultobj = 0;
51296 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51297 wxWindow *arg2 = (wxWindow *) 0 ;
51298 wxEdge arg3 ;
51299 int arg4 = (int) 0 ;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 void *argp2 = 0 ;
51303 int res2 = 0 ;
51304 int val3 ;
51305 int ecode3 = 0 ;
51306 int val4 ;
51307 int ecode4 = 0 ;
51308 PyObject * obj0 = 0 ;
51309 PyObject * obj1 = 0 ;
51310 PyObject * obj2 = 0 ;
51311 PyObject * obj3 = 0 ;
51312 char * kwnames[] = {
51313 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51314 };
51315
51316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51318 if (!SWIG_IsOK(res1)) {
51319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51320 }
51321 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51323 if (!SWIG_IsOK(res2)) {
51324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51325 }
51326 arg2 = reinterpret_cast< wxWindow * >(argp2);
51327 ecode3 = SWIG_AsVal_int(obj2, &val3);
51328 if (!SWIG_IsOK(ecode3)) {
51329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51330 }
51331 arg3 = static_cast< wxEdge >(val3);
51332 if (obj3) {
51333 ecode4 = SWIG_AsVal_int(obj3, &val4);
51334 if (!SWIG_IsOK(ecode4)) {
51335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51336 }
51337 arg4 = static_cast< int >(val4);
51338 }
51339 {
51340 PyThreadState* __tstate = wxPyBeginAllowThreads();
51341 (arg1)->SameAs(arg2,arg3,arg4);
51342 wxPyEndAllowThreads(__tstate);
51343 if (PyErr_Occurred()) SWIG_fail;
51344 }
51345 resultobj = SWIG_Py_Void();
51346 return resultobj;
51347 fail:
51348 return NULL;
51349 }
51350
51351
51352 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51353 PyObject *resultobj = 0;
51354 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51355 wxWindow *arg2 = (wxWindow *) 0 ;
51356 wxEdge arg3 ;
51357 int arg4 ;
51358 void *argp1 = 0 ;
51359 int res1 = 0 ;
51360 void *argp2 = 0 ;
51361 int res2 = 0 ;
51362 int val3 ;
51363 int ecode3 = 0 ;
51364 int val4 ;
51365 int ecode4 = 0 ;
51366 PyObject * obj0 = 0 ;
51367 PyObject * obj1 = 0 ;
51368 PyObject * obj2 = 0 ;
51369 PyObject * obj3 = 0 ;
51370 char * kwnames[] = {
51371 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51372 };
51373
51374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51376 if (!SWIG_IsOK(res1)) {
51377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51378 }
51379 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51381 if (!SWIG_IsOK(res2)) {
51382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51383 }
51384 arg2 = reinterpret_cast< wxWindow * >(argp2);
51385 ecode3 = SWIG_AsVal_int(obj2, &val3);
51386 if (!SWIG_IsOK(ecode3)) {
51387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51388 }
51389 arg3 = static_cast< wxEdge >(val3);
51390 ecode4 = SWIG_AsVal_int(obj3, &val4);
51391 if (!SWIG_IsOK(ecode4)) {
51392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51393 }
51394 arg4 = static_cast< int >(val4);
51395 {
51396 PyThreadState* __tstate = wxPyBeginAllowThreads();
51397 (arg1)->PercentOf(arg2,arg3,arg4);
51398 wxPyEndAllowThreads(__tstate);
51399 if (PyErr_Occurred()) SWIG_fail;
51400 }
51401 resultobj = SWIG_Py_Void();
51402 return resultobj;
51403 fail:
51404 return NULL;
51405 }
51406
51407
51408 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51409 PyObject *resultobj = 0;
51410 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51411 int arg2 ;
51412 void *argp1 = 0 ;
51413 int res1 = 0 ;
51414 int val2 ;
51415 int ecode2 = 0 ;
51416 PyObject * obj0 = 0 ;
51417 PyObject * obj1 = 0 ;
51418 char * kwnames[] = {
51419 (char *) "self",(char *) "val", NULL
51420 };
51421
51422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51424 if (!SWIG_IsOK(res1)) {
51425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51426 }
51427 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51428 ecode2 = SWIG_AsVal_int(obj1, &val2);
51429 if (!SWIG_IsOK(ecode2)) {
51430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51431 }
51432 arg2 = static_cast< int >(val2);
51433 {
51434 PyThreadState* __tstate = wxPyBeginAllowThreads();
51435 (arg1)->Absolute(arg2);
51436 wxPyEndAllowThreads(__tstate);
51437 if (PyErr_Occurred()) SWIG_fail;
51438 }
51439 resultobj = SWIG_Py_Void();
51440 return resultobj;
51441 fail:
51442 return NULL;
51443 }
51444
51445
51446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51447 PyObject *resultobj = 0;
51448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51449 void *argp1 = 0 ;
51450 int res1 = 0 ;
51451 PyObject *swig_obj[1] ;
51452
51453 if (!args) SWIG_fail;
51454 swig_obj[0] = args;
51455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51456 if (!SWIG_IsOK(res1)) {
51457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51458 }
51459 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51460 {
51461 PyThreadState* __tstate = wxPyBeginAllowThreads();
51462 (arg1)->Unconstrained();
51463 wxPyEndAllowThreads(__tstate);
51464 if (PyErr_Occurred()) SWIG_fail;
51465 }
51466 resultobj = SWIG_Py_Void();
51467 return resultobj;
51468 fail:
51469 return NULL;
51470 }
51471
51472
51473 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51474 PyObject *resultobj = 0;
51475 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51476 void *argp1 = 0 ;
51477 int res1 = 0 ;
51478 PyObject *swig_obj[1] ;
51479
51480 if (!args) SWIG_fail;
51481 swig_obj[0] = args;
51482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51483 if (!SWIG_IsOK(res1)) {
51484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51485 }
51486 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51487 {
51488 PyThreadState* __tstate = wxPyBeginAllowThreads();
51489 (arg1)->AsIs();
51490 wxPyEndAllowThreads(__tstate);
51491 if (PyErr_Occurred()) SWIG_fail;
51492 }
51493 resultobj = SWIG_Py_Void();
51494 return resultobj;
51495 fail:
51496 return NULL;
51497 }
51498
51499
51500 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51501 PyObject *resultobj = 0;
51502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51503 wxWindow *result = 0 ;
51504 void *argp1 = 0 ;
51505 int res1 = 0 ;
51506 PyObject *swig_obj[1] ;
51507
51508 if (!args) SWIG_fail;
51509 swig_obj[0] = args;
51510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51511 if (!SWIG_IsOK(res1)) {
51512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51513 }
51514 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51515 {
51516 PyThreadState* __tstate = wxPyBeginAllowThreads();
51517 result = (wxWindow *)(arg1)->GetOtherWindow();
51518 wxPyEndAllowThreads(__tstate);
51519 if (PyErr_Occurred()) SWIG_fail;
51520 }
51521 {
51522 resultobj = wxPyMake_wxObject(result, 0);
51523 }
51524 return resultobj;
51525 fail:
51526 return NULL;
51527 }
51528
51529
51530 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51531 PyObject *resultobj = 0;
51532 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51533 wxEdge result;
51534 void *argp1 = 0 ;
51535 int res1 = 0 ;
51536 PyObject *swig_obj[1] ;
51537
51538 if (!args) SWIG_fail;
51539 swig_obj[0] = args;
51540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51541 if (!SWIG_IsOK(res1)) {
51542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51543 }
51544 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51545 {
51546 PyThreadState* __tstate = wxPyBeginAllowThreads();
51547 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51548 wxPyEndAllowThreads(__tstate);
51549 if (PyErr_Occurred()) SWIG_fail;
51550 }
51551 resultobj = SWIG_From_int(static_cast< int >(result));
51552 return resultobj;
51553 fail:
51554 return NULL;
51555 }
51556
51557
51558 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51559 PyObject *resultobj = 0;
51560 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51561 wxEdge arg2 ;
51562 void *argp1 = 0 ;
51563 int res1 = 0 ;
51564 int val2 ;
51565 int ecode2 = 0 ;
51566 PyObject * obj0 = 0 ;
51567 PyObject * obj1 = 0 ;
51568 char * kwnames[] = {
51569 (char *) "self",(char *) "which", NULL
51570 };
51571
51572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51574 if (!SWIG_IsOK(res1)) {
51575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51576 }
51577 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51578 ecode2 = SWIG_AsVal_int(obj1, &val2);
51579 if (!SWIG_IsOK(ecode2)) {
51580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51581 }
51582 arg2 = static_cast< wxEdge >(val2);
51583 {
51584 PyThreadState* __tstate = wxPyBeginAllowThreads();
51585 (arg1)->SetEdge(arg2);
51586 wxPyEndAllowThreads(__tstate);
51587 if (PyErr_Occurred()) SWIG_fail;
51588 }
51589 resultobj = SWIG_Py_Void();
51590 return resultobj;
51591 fail:
51592 return NULL;
51593 }
51594
51595
51596 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51597 PyObject *resultobj = 0;
51598 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51599 int arg2 ;
51600 void *argp1 = 0 ;
51601 int res1 = 0 ;
51602 int val2 ;
51603 int ecode2 = 0 ;
51604 PyObject * obj0 = 0 ;
51605 PyObject * obj1 = 0 ;
51606 char * kwnames[] = {
51607 (char *) "self",(char *) "v", NULL
51608 };
51609
51610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51612 if (!SWIG_IsOK(res1)) {
51613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51614 }
51615 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51616 ecode2 = SWIG_AsVal_int(obj1, &val2);
51617 if (!SWIG_IsOK(ecode2)) {
51618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51619 }
51620 arg2 = static_cast< int >(val2);
51621 {
51622 PyThreadState* __tstate = wxPyBeginAllowThreads();
51623 (arg1)->SetValue(arg2);
51624 wxPyEndAllowThreads(__tstate);
51625 if (PyErr_Occurred()) SWIG_fail;
51626 }
51627 resultobj = SWIG_Py_Void();
51628 return resultobj;
51629 fail:
51630 return NULL;
51631 }
51632
51633
51634 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51635 PyObject *resultobj = 0;
51636 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51637 int result;
51638 void *argp1 = 0 ;
51639 int res1 = 0 ;
51640 PyObject *swig_obj[1] ;
51641
51642 if (!args) SWIG_fail;
51643 swig_obj[0] = args;
51644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51645 if (!SWIG_IsOK(res1)) {
51646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51647 }
51648 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51649 {
51650 PyThreadState* __tstate = wxPyBeginAllowThreads();
51651 result = (int)(arg1)->GetMargin();
51652 wxPyEndAllowThreads(__tstate);
51653 if (PyErr_Occurred()) SWIG_fail;
51654 }
51655 resultobj = SWIG_From_int(static_cast< int >(result));
51656 return resultobj;
51657 fail:
51658 return NULL;
51659 }
51660
51661
51662 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51663 PyObject *resultobj = 0;
51664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51665 int arg2 ;
51666 void *argp1 = 0 ;
51667 int res1 = 0 ;
51668 int val2 ;
51669 int ecode2 = 0 ;
51670 PyObject * obj0 = 0 ;
51671 PyObject * obj1 = 0 ;
51672 char * kwnames[] = {
51673 (char *) "self",(char *) "m", NULL
51674 };
51675
51676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51678 if (!SWIG_IsOK(res1)) {
51679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51680 }
51681 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51682 ecode2 = SWIG_AsVal_int(obj1, &val2);
51683 if (!SWIG_IsOK(ecode2)) {
51684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51685 }
51686 arg2 = static_cast< int >(val2);
51687 {
51688 PyThreadState* __tstate = wxPyBeginAllowThreads();
51689 (arg1)->SetMargin(arg2);
51690 wxPyEndAllowThreads(__tstate);
51691 if (PyErr_Occurred()) SWIG_fail;
51692 }
51693 resultobj = SWIG_Py_Void();
51694 return resultobj;
51695 fail:
51696 return NULL;
51697 }
51698
51699
51700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51701 PyObject *resultobj = 0;
51702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51703 int result;
51704 void *argp1 = 0 ;
51705 int res1 = 0 ;
51706 PyObject *swig_obj[1] ;
51707
51708 if (!args) SWIG_fail;
51709 swig_obj[0] = args;
51710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51711 if (!SWIG_IsOK(res1)) {
51712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51713 }
51714 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51715 {
51716 PyThreadState* __tstate = wxPyBeginAllowThreads();
51717 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51718 wxPyEndAllowThreads(__tstate);
51719 if (PyErr_Occurred()) SWIG_fail;
51720 }
51721 resultobj = SWIG_From_int(static_cast< int >(result));
51722 return resultobj;
51723 fail:
51724 return NULL;
51725 }
51726
51727
51728 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51729 PyObject *resultobj = 0;
51730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51731 int result;
51732 void *argp1 = 0 ;
51733 int res1 = 0 ;
51734 PyObject *swig_obj[1] ;
51735
51736 if (!args) SWIG_fail;
51737 swig_obj[0] = args;
51738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51739 if (!SWIG_IsOK(res1)) {
51740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51741 }
51742 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51743 {
51744 PyThreadState* __tstate = wxPyBeginAllowThreads();
51745 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51746 wxPyEndAllowThreads(__tstate);
51747 if (PyErr_Occurred()) SWIG_fail;
51748 }
51749 resultobj = SWIG_From_int(static_cast< int >(result));
51750 return resultobj;
51751 fail:
51752 return NULL;
51753 }
51754
51755
51756 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51757 PyObject *resultobj = 0;
51758 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51759 int result;
51760 void *argp1 = 0 ;
51761 int res1 = 0 ;
51762 PyObject *swig_obj[1] ;
51763
51764 if (!args) SWIG_fail;
51765 swig_obj[0] = args;
51766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51767 if (!SWIG_IsOK(res1)) {
51768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51769 }
51770 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_From_int(static_cast< int >(result));
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51785 PyObject *resultobj = 0;
51786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51787 bool 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_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51797 }
51798 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51799 {
51800 PyThreadState* __tstate = wxPyBeginAllowThreads();
51801 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51802 wxPyEndAllowThreads(__tstate);
51803 if (PyErr_Occurred()) SWIG_fail;
51804 }
51805 {
51806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51807 }
51808 return resultobj;
51809 fail:
51810 return NULL;
51811 }
51812
51813
51814 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51815 PyObject *resultobj = 0;
51816 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51817 bool arg2 ;
51818 void *argp1 = 0 ;
51819 int res1 = 0 ;
51820 bool val2 ;
51821 int ecode2 = 0 ;
51822 PyObject * obj0 = 0 ;
51823 PyObject * obj1 = 0 ;
51824 char * kwnames[] = {
51825 (char *) "self",(char *) "d", NULL
51826 };
51827
51828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51830 if (!SWIG_IsOK(res1)) {
51831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51832 }
51833 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51835 if (!SWIG_IsOK(ecode2)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51837 }
51838 arg2 = static_cast< bool >(val2);
51839 {
51840 PyThreadState* __tstate = wxPyBeginAllowThreads();
51841 (arg1)->SetDone(arg2);
51842 wxPyEndAllowThreads(__tstate);
51843 if (PyErr_Occurred()) SWIG_fail;
51844 }
51845 resultobj = SWIG_Py_Void();
51846 return resultobj;
51847 fail:
51848 return NULL;
51849 }
51850
51851
51852 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51853 PyObject *resultobj = 0;
51854 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51855 wxRelationship result;
51856 void *argp1 = 0 ;
51857 int res1 = 0 ;
51858 PyObject *swig_obj[1] ;
51859
51860 if (!args) SWIG_fail;
51861 swig_obj[0] = args;
51862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51863 if (!SWIG_IsOK(res1)) {
51864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51865 }
51866 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51867 {
51868 PyThreadState* __tstate = wxPyBeginAllowThreads();
51869 result = (wxRelationship)(arg1)->GetRelationship();
51870 wxPyEndAllowThreads(__tstate);
51871 if (PyErr_Occurred()) SWIG_fail;
51872 }
51873 resultobj = SWIG_From_int(static_cast< int >(result));
51874 return resultobj;
51875 fail:
51876 return NULL;
51877 }
51878
51879
51880 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51881 PyObject *resultobj = 0;
51882 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51883 wxRelationship arg2 ;
51884 void *argp1 = 0 ;
51885 int res1 = 0 ;
51886 int val2 ;
51887 int ecode2 = 0 ;
51888 PyObject * obj0 = 0 ;
51889 PyObject * obj1 = 0 ;
51890 char * kwnames[] = {
51891 (char *) "self",(char *) "r", NULL
51892 };
51893
51894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51896 if (!SWIG_IsOK(res1)) {
51897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51898 }
51899 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51900 ecode2 = SWIG_AsVal_int(obj1, &val2);
51901 if (!SWIG_IsOK(ecode2)) {
51902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51903 }
51904 arg2 = static_cast< wxRelationship >(val2);
51905 {
51906 PyThreadState* __tstate = wxPyBeginAllowThreads();
51907 (arg1)->SetRelationship(arg2);
51908 wxPyEndAllowThreads(__tstate);
51909 if (PyErr_Occurred()) SWIG_fail;
51910 }
51911 resultobj = SWIG_Py_Void();
51912 return resultobj;
51913 fail:
51914 return NULL;
51915 }
51916
51917
51918 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51919 PyObject *resultobj = 0;
51920 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51921 wxWindow *arg2 = (wxWindow *) 0 ;
51922 bool result;
51923 void *argp1 = 0 ;
51924 int res1 = 0 ;
51925 void *argp2 = 0 ;
51926 int res2 = 0 ;
51927 PyObject * obj0 = 0 ;
51928 PyObject * obj1 = 0 ;
51929 char * kwnames[] = {
51930 (char *) "self",(char *) "otherW", NULL
51931 };
51932
51933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51935 if (!SWIG_IsOK(res1)) {
51936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51937 }
51938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51940 if (!SWIG_IsOK(res2)) {
51941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51942 }
51943 arg2 = reinterpret_cast< wxWindow * >(argp2);
51944 {
51945 PyThreadState* __tstate = wxPyBeginAllowThreads();
51946 result = (bool)(arg1)->ResetIfWin(arg2);
51947 wxPyEndAllowThreads(__tstate);
51948 if (PyErr_Occurred()) SWIG_fail;
51949 }
51950 {
51951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51952 }
51953 return resultobj;
51954 fail:
51955 return NULL;
51956 }
51957
51958
51959 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51960 PyObject *resultobj = 0;
51961 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51962 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51963 wxWindow *arg3 = (wxWindow *) 0 ;
51964 bool result;
51965 void *argp1 = 0 ;
51966 int res1 = 0 ;
51967 void *argp2 = 0 ;
51968 int res2 = 0 ;
51969 void *argp3 = 0 ;
51970 int res3 = 0 ;
51971 PyObject * obj0 = 0 ;
51972 PyObject * obj1 = 0 ;
51973 PyObject * obj2 = 0 ;
51974 char * kwnames[] = {
51975 (char *) "self",(char *) "constraints",(char *) "win", NULL
51976 };
51977
51978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51980 if (!SWIG_IsOK(res1)) {
51981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51982 }
51983 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51985 if (!SWIG_IsOK(res2)) {
51986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51987 }
51988 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51989 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51990 if (!SWIG_IsOK(res3)) {
51991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51992 }
51993 arg3 = reinterpret_cast< wxWindow * >(argp3);
51994 {
51995 PyThreadState* __tstate = wxPyBeginAllowThreads();
51996 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51997 wxPyEndAllowThreads(__tstate);
51998 if (PyErr_Occurred()) SWIG_fail;
51999 }
52000 {
52001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52002 }
52003 return resultobj;
52004 fail:
52005 return NULL;
52006 }
52007
52008
52009 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52010 PyObject *resultobj = 0;
52011 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52012 wxEdge arg2 ;
52013 wxWindow *arg3 = (wxWindow *) 0 ;
52014 wxWindow *arg4 = (wxWindow *) 0 ;
52015 int result;
52016 void *argp1 = 0 ;
52017 int res1 = 0 ;
52018 int val2 ;
52019 int ecode2 = 0 ;
52020 void *argp3 = 0 ;
52021 int res3 = 0 ;
52022 void *argp4 = 0 ;
52023 int res4 = 0 ;
52024 PyObject * obj0 = 0 ;
52025 PyObject * obj1 = 0 ;
52026 PyObject * obj2 = 0 ;
52027 PyObject * obj3 = 0 ;
52028 char * kwnames[] = {
52029 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52030 };
52031
52032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52034 if (!SWIG_IsOK(res1)) {
52035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52036 }
52037 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52038 ecode2 = SWIG_AsVal_int(obj1, &val2);
52039 if (!SWIG_IsOK(ecode2)) {
52040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52041 }
52042 arg2 = static_cast< wxEdge >(val2);
52043 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52044 if (!SWIG_IsOK(res3)) {
52045 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52046 }
52047 arg3 = reinterpret_cast< wxWindow * >(argp3);
52048 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52049 if (!SWIG_IsOK(res4)) {
52050 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52051 }
52052 arg4 = reinterpret_cast< wxWindow * >(argp4);
52053 {
52054 PyThreadState* __tstate = wxPyBeginAllowThreads();
52055 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52056 wxPyEndAllowThreads(__tstate);
52057 if (PyErr_Occurred()) SWIG_fail;
52058 }
52059 resultobj = SWIG_From_int(static_cast< int >(result));
52060 return resultobj;
52061 fail:
52062 return NULL;
52063 }
52064
52065
52066 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52067 PyObject *obj;
52068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52069 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52070 return SWIG_Py_Void();
52071 }
52072
52073 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52074 PyObject *resultobj = 0;
52075 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52076 wxIndividualLayoutConstraint *result = 0 ;
52077 void *argp1 = 0 ;
52078 int res1 = 0 ;
52079 PyObject *swig_obj[1] ;
52080
52081 if (!args) SWIG_fail;
52082 swig_obj[0] = args;
52083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52084 if (!SWIG_IsOK(res1)) {
52085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52086 }
52087 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52088 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52090 return resultobj;
52091 fail:
52092 return NULL;
52093 }
52094
52095
52096 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52097 PyObject *resultobj = 0;
52098 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52099 wxIndividualLayoutConstraint *result = 0 ;
52100 void *argp1 = 0 ;
52101 int res1 = 0 ;
52102 PyObject *swig_obj[1] ;
52103
52104 if (!args) SWIG_fail;
52105 swig_obj[0] = args;
52106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52107 if (!SWIG_IsOK(res1)) {
52108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52109 }
52110 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52111 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52113 return resultobj;
52114 fail:
52115 return NULL;
52116 }
52117
52118
52119 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52120 PyObject *resultobj = 0;
52121 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52122 wxIndividualLayoutConstraint *result = 0 ;
52123 void *argp1 = 0 ;
52124 int res1 = 0 ;
52125 PyObject *swig_obj[1] ;
52126
52127 if (!args) SWIG_fail;
52128 swig_obj[0] = args;
52129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52130 if (!SWIG_IsOK(res1)) {
52131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52132 }
52133 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52134 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52136 return resultobj;
52137 fail:
52138 return NULL;
52139 }
52140
52141
52142 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52143 PyObject *resultobj = 0;
52144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52145 wxIndividualLayoutConstraint *result = 0 ;
52146 void *argp1 = 0 ;
52147 int res1 = 0 ;
52148 PyObject *swig_obj[1] ;
52149
52150 if (!args) SWIG_fail;
52151 swig_obj[0] = args;
52152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52153 if (!SWIG_IsOK(res1)) {
52154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52155 }
52156 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52157 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52159 return resultobj;
52160 fail:
52161 return NULL;
52162 }
52163
52164
52165 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52166 PyObject *resultobj = 0;
52167 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52168 wxIndividualLayoutConstraint *result = 0 ;
52169 void *argp1 = 0 ;
52170 int res1 = 0 ;
52171 PyObject *swig_obj[1] ;
52172
52173 if (!args) SWIG_fail;
52174 swig_obj[0] = args;
52175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52176 if (!SWIG_IsOK(res1)) {
52177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52178 }
52179 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52180 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52182 return resultobj;
52183 fail:
52184 return NULL;
52185 }
52186
52187
52188 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52189 PyObject *resultobj = 0;
52190 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52191 wxIndividualLayoutConstraint *result = 0 ;
52192 void *argp1 = 0 ;
52193 int res1 = 0 ;
52194 PyObject *swig_obj[1] ;
52195
52196 if (!args) SWIG_fail;
52197 swig_obj[0] = args;
52198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52201 }
52202 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52203 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52205 return resultobj;
52206 fail:
52207 return NULL;
52208 }
52209
52210
52211 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52212 PyObject *resultobj = 0;
52213 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52214 wxIndividualLayoutConstraint *result = 0 ;
52215 void *argp1 = 0 ;
52216 int res1 = 0 ;
52217 PyObject *swig_obj[1] ;
52218
52219 if (!args) SWIG_fail;
52220 swig_obj[0] = args;
52221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52222 if (!SWIG_IsOK(res1)) {
52223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52224 }
52225 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52226 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52228 return resultobj;
52229 fail:
52230 return NULL;
52231 }
52232
52233
52234 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52235 PyObject *resultobj = 0;
52236 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52237 wxIndividualLayoutConstraint *result = 0 ;
52238 void *argp1 = 0 ;
52239 int res1 = 0 ;
52240 PyObject *swig_obj[1] ;
52241
52242 if (!args) SWIG_fail;
52243 swig_obj[0] = args;
52244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52245 if (!SWIG_IsOK(res1)) {
52246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52247 }
52248 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52249 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52251 return resultobj;
52252 fail:
52253 return NULL;
52254 }
52255
52256
52257 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52258 PyObject *resultobj = 0;
52259 wxLayoutConstraints *result = 0 ;
52260
52261 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52262 {
52263 PyThreadState* __tstate = wxPyBeginAllowThreads();
52264 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52265 wxPyEndAllowThreads(__tstate);
52266 if (PyErr_Occurred()) SWIG_fail;
52267 }
52268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52269 return resultobj;
52270 fail:
52271 return NULL;
52272 }
52273
52274
52275 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52276 PyObject *resultobj = 0;
52277 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52278 void *argp1 = 0 ;
52279 int res1 = 0 ;
52280 PyObject *swig_obj[1] ;
52281
52282 if (!args) SWIG_fail;
52283 swig_obj[0] = args;
52284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52285 if (!SWIG_IsOK(res1)) {
52286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52287 }
52288 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52289 {
52290 PyThreadState* __tstate = wxPyBeginAllowThreads();
52291 delete arg1;
52292
52293 wxPyEndAllowThreads(__tstate);
52294 if (PyErr_Occurred()) SWIG_fail;
52295 }
52296 resultobj = SWIG_Py_Void();
52297 return resultobj;
52298 fail:
52299 return NULL;
52300 }
52301
52302
52303 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52304 PyObject *resultobj = 0;
52305 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52306 wxWindow *arg2 = (wxWindow *) 0 ;
52307 int *arg3 = (int *) 0 ;
52308 bool result;
52309 void *argp1 = 0 ;
52310 int res1 = 0 ;
52311 void *argp2 = 0 ;
52312 int res2 = 0 ;
52313 int temp3 ;
52314 int res3 = SWIG_TMPOBJ ;
52315 PyObject * obj0 = 0 ;
52316 PyObject * obj1 = 0 ;
52317 char * kwnames[] = {
52318 (char *) "self",(char *) "win", NULL
52319 };
52320
52321 arg3 = &temp3;
52322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52324 if (!SWIG_IsOK(res1)) {
52325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52326 }
52327 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52329 if (!SWIG_IsOK(res2)) {
52330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52331 }
52332 arg2 = reinterpret_cast< wxWindow * >(argp2);
52333 {
52334 PyThreadState* __tstate = wxPyBeginAllowThreads();
52335 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52336 wxPyEndAllowThreads(__tstate);
52337 if (PyErr_Occurred()) SWIG_fail;
52338 }
52339 {
52340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52341 }
52342 if (SWIG_IsTmpObj(res3)) {
52343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52344 } else {
52345 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52347 }
52348 return resultobj;
52349 fail:
52350 return NULL;
52351 }
52352
52353
52354 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52355 PyObject *resultobj = 0;
52356 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52357 bool result;
52358 void *argp1 = 0 ;
52359 int res1 = 0 ;
52360 PyObject *swig_obj[1] ;
52361
52362 if (!args) SWIG_fail;
52363 swig_obj[0] = args;
52364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52365 if (!SWIG_IsOK(res1)) {
52366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52367 }
52368 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52369 {
52370 PyThreadState* __tstate = wxPyBeginAllowThreads();
52371 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52372 wxPyEndAllowThreads(__tstate);
52373 if (PyErr_Occurred()) SWIG_fail;
52374 }
52375 {
52376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52377 }
52378 return resultobj;
52379 fail:
52380 return NULL;
52381 }
52382
52383
52384 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52385 PyObject *obj;
52386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52387 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52388 return SWIG_Py_Void();
52389 }
52390
52391 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52392 return SWIG_Python_InitShadowInstance(args);
52393 }
52394
52395 static PyMethodDef SwigMethods[] = {
52396 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52397 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52398 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52399 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52400 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52401 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52402 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52403 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52404 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52405 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52407 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52409 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52417 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52418 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52419 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52421 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52422 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52423 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52424 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52425 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52426 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52427 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52429 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52430 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52434 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52435 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52436 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52437 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52438 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52439 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52440 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52441 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52443 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52449 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52451 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52452 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52453 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52456 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52458 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52459 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52460 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52461 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52463 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52465 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52467 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52469 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52471 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52472 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52473 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52474 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52475 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52476 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52477 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52478 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52479 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52480 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52496 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52497 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52498 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52499 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52500 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52501 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52502 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52503 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52504 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52505 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52507 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52508 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52509 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52514 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52515 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52516 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52517 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52524 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52531 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52532 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52533 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52534 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52536 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52537 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52538 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52540 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52541 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52542 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52543 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52548 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52549 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52550 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52551 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52552 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52553 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52556 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52557 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52558 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52560 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52561 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52563 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52564 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52565 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52566 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52567 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52568 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52569 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52570 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52571 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52572 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52573 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52578 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52584 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52585 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52586 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52587 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52589 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52590 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52592 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52594 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52597 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52598 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52599 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52602 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52603 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52604 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52608 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52609 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52610 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52614 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52619 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52620 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52621 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52622 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52623 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52624 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52625 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52631 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52632 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52634 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52635 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52636 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52642 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52643 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52645 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52646 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52647 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52648 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52649 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52650 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52651 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52652 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52654 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52655 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52656 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52657 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52658 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52659 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52660 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52661 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52663 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52672 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52684 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52685 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52700 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52701 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52702 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52703 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52706 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52708 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52710 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52712 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52714 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52717 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52718 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52719 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52720 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52722 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52739 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52740 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52746 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52747 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52748 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52749 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52750 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52751 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52752 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52753 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52754 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52755 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52756 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52757 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52758 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52759 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52760 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52761 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52762 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52763 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52764 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52765 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52766 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52767 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52768 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52769 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52770 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52771 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52772 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52773 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52774 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52775 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52776 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52777 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52778 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52779 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52780 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52782 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52783 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52784 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52785 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52788 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52792 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52796 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52797 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52798 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52799 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52801 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52802 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52804 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52806 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52808 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52810 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52811 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52812 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52814 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52815 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52817 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52818 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52819 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52821 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52822 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52823 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52825 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52827 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52828 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52829 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52831 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52833 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52834 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52836 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52837 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52838 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52840 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52841 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52842 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52843 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52844 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52846 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52847 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52850 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52851 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52853 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52854 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52857 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52858 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52860 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52866 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52867 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52868 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52869 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52870 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52871 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52872 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52873 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52874 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52875 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52876 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52877 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52878 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52879 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52880 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52881 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52882 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52883 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52884 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52885 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52886 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52887 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52888 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52889 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52891 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52892 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52893 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52894 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52895 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52896 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52897 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52898 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52899 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52900 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52901 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52902 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52903 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52904 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52905 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52906 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52907 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52908 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52909 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52910 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52911 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52912 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52913 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52914 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52915 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52916 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52917 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52918 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52919 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52920 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52921 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52922 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52924 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52925 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52927 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52928 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52929 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52930 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52932 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52933 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52934 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52935 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52936 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52937 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52938 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52939 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52940 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52941 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52942 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52943 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52944 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52945 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52946 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52947 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52948 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52949 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52950 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52951 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52952 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52953 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52954 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52955 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52956 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52957 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52958 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52959 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52960 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52961 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52962 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52963 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52964 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52965 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52966 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52967 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52968 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52970 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52971 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52974 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52975 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52976 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52977 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52978 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52979 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52981 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52982 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52985 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52986 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52988 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52989 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52991 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52994 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52995 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52996 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52998 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53000 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53001 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53003 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53004 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53005 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53007 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53008 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53009 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53011 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53012 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53014 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53015 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53016 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53017 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53018 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53021 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53023 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53025 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53026 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53030 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53031 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53032 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53034 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53035 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53036 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53038 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53039 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53040 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53041 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53042 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53043 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53045 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53046 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53047 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53048 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53049 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53050 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53051 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53052 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53058 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53060 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53062 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53063 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53064 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53065 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53066 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53069 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53070 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53071 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53072 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53073 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53074 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53077 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53078 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53079 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53082 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53083 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53085 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53086 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53088 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53090 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53093 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53095 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53096 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53098 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53099 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53100 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53102 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53103 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53104 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53106 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53108 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53110 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53112 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53114 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53116 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53117 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53119 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53121 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53122 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53123 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53125 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53127 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53128 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53129 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53131 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53133 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53135 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53136 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53138 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53140 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53142 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53144 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53145 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53147 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53148 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53149 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53150 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53151 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53152 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53153 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53154 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53156 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53158 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53160 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53162 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53164 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53166 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53167 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53168 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53169 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53170 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53171 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53177 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53178 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53179 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53180 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53181 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53182 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53183 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53185 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53187 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53188 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53190 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53191 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53192 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53193 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53195 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53196 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53197 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53198 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53200 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53203 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53204 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53207 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53209 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53210 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53211 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53212 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53213 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53215 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53216 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53217 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53218 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53220 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53221 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53222 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53223 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53224 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53225 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53226 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53227 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53228 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53231 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53234 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53235 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53236 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53238 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53240 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53242 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53244 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53245 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53255 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53256 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53260 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53261 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53262 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53263 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53264 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53265 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53266 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53267 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53268 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53269 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53270 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53271 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53272 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53273 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53274 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53276 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53277 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53280 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53281 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53286 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53287 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53290 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53291 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53292 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53293 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53296 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53297 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53298 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53300 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53302 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53303 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53304 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53306 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53308 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53310 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53313 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53314 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53315 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53316 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53317 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53318 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53319 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53325 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53326 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53327 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53328 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53334 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53340 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53341 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53342 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53343 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53344 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53346 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53356 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53357 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53358 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53359 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53362 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53363 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53364 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53365 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53367 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53368 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53372 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53378 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53379 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53380 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53381 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53383 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53384 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53386 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53389 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53391 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53392 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53393 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53402 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53406 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53408 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53418 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53419 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53420 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53421 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53424 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53427 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53429 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53432 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53434 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53435 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53438 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53440 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53441 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53442 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53443 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53444 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53449 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53450 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53451 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53453 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53454 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53455 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53457 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53459 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53460 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53461 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53463 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53464 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53467 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53474 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53481 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53489 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53492 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53493 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53506 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53508 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53510 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53511 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53513 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53515 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53516 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53518 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53519 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53520 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53524 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53543 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53544 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53546 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53548 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53549 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53550 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53552 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53553 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53556 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53557 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53559 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53560 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53562 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53565 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53566 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53568 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53570 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53572 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53573 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53575 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53576 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53579 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53581 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53583 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53585 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53588 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53590 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53591 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53592 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53594 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53595 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53596 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53598 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53601 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53603 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53604 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53608 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53612 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53613 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53615 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53619 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53621 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53623 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53624 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53625 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53626 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53630 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53631 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53632 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53633 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53635 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53636 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53641 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53642 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53643 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53644 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53645 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53647 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53649 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53651 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53652 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53654 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53656 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53659 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53660 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53661 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53663 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53664 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53665 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53679 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53680 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53681 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53682 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53683 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53684 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53690 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53691 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53695 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53696 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53698 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53699 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53701 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53703 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53704 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53706 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53707 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53708 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53714 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53715 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53716 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53717 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53718 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53719 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53726 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53728 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53729 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53730 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53731 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53732 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53733 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53735 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53739 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53740 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53741 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53742 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53743 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53744 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53745 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53747 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53748 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53749 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53755 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53756 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53757 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53759 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53760 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53761 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53767 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53768 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53770 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53771 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53775 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53776 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53781 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53782 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53784 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53785 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53790 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53792 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53793 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53794 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53795 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53796 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53801 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53802 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53811 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53812 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53813 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53814 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53817 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53819 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53820 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53821 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53822 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53824 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53829 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53830 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53831 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53832 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53833 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53834 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53835 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53836 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53837 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53838 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53839 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53841 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53842 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53843 { NULL, NULL, 0, NULL }
53844 };
53845
53846
53847 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53848
53849 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53850 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53851 }
53852 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53853 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53854 }
53855 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53856 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53857 }
53858 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53859 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53860 }
53861 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53862 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53863 }
53864 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53865 return (void *)((wxSizer *) ((wxGridSizer *) x));
53866 }
53867 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53868 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53869 }
53870 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53871 return (void *)((wxSizer *) ((wxPySizer *) x));
53872 }
53873 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53874 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53875 }
53876 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53877 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53878 }
53879 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53880 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53881 }
53882 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53883 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53884 }
53885 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53886 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53887 }
53888 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53889 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53890 }
53891 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53892 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53893 }
53894 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53895 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53896 }
53897 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53898 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53899 }
53900 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53901 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53902 }
53903 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53904 return (void *)((wxEvent *) ((wxPyEvent *) x));
53905 }
53906 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53907 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53908 }
53909 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53910 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53911 }
53912 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53913 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53914 }
53915 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53916 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53917 }
53918 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53919 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53920 }
53921 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53922 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53923 }
53924 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53925 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53926 }
53927 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53928 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53929 }
53930 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53931 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53932 }
53933 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53934 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53935 }
53936 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53937 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53938 }
53939 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53940 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53941 }
53942 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53943 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53944 }
53945 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53946 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53947 }
53948 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53949 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53950 }
53951 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53952 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53953 }
53954 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53955 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53956 }
53957 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53958 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53959 }
53960 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53961 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53962 }
53963 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53964 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53965 }
53966 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53967 return (void *)((wxEvent *) ((wxShowEvent *) x));
53968 }
53969 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53970 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53971 }
53972 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53973 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53974 }
53975 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53976 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53977 }
53978 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53979 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53980 }
53981 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53982 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53983 }
53984 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53985 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53986 }
53987 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53988 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53989 }
53990 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53991 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53992 }
53993 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53994 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53995 }
53996 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53997 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53998 }
53999 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54000 return (void *)((wxControl *) ((wxControlWithItems *) x));
54001 }
54002 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54003 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54004 }
54005 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54006 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54007 }
54008 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54009 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54010 }
54011 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54012 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54013 }
54014 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54015 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54016 }
54017 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54018 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54019 }
54020 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54021 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54022 }
54023 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54024 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54025 }
54026 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54027 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54028 }
54029 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54030 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54031 }
54032 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54033 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54034 }
54035 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54036 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54037 }
54038 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54039 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54040 }
54041 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54042 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54043 }
54044 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54045 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54046 }
54047 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54048 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54049 }
54050 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54051 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54052 }
54053 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54054 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54055 }
54056 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54057 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54058 }
54059 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54060 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54061 }
54062 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54063 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54064 }
54065 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54066 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54067 }
54068 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54069 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54070 }
54071 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54072 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54073 }
54074 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54075 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54076 }
54077 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54078 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54079 }
54080 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54081 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54082 }
54083 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54084 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54085 }
54086 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54087 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54088 }
54089 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54090 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54091 }
54092 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54093 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54094 }
54095 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54096 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54097 }
54098 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54099 return (void *)((wxObject *) ((wxSizerItem *) x));
54100 }
54101 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54103 }
54104 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54105 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54106 }
54107 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54108 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54109 }
54110 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54111 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54112 }
54113 static void *_p_wxSizerTo_p_wxObject(void *x) {
54114 return (void *)((wxObject *) ((wxSizer *) x));
54115 }
54116 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54117 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54118 }
54119 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54120 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54121 }
54122 static void *_p_wxEventTo_p_wxObject(void *x) {
54123 return (void *)((wxObject *) ((wxEvent *) x));
54124 }
54125 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54126 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54127 }
54128 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54129 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54130 }
54131 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54132 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54133 }
54134 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54135 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54136 }
54137 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54138 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54139 }
54140 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54141 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54142 }
54143 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54144 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54145 }
54146 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54147 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54148 }
54149 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54150 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54151 }
54152 static void *_p_wxControlTo_p_wxObject(void *x) {
54153 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54154 }
54155 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54156 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54157 }
54158 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54159 return (void *)((wxObject *) ((wxFSFile *) x));
54160 }
54161 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54162 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54163 }
54164 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54165 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54166 }
54167 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54168 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54169 }
54170 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54171 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54172 }
54173 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54174 return (void *)((wxObject *) ((wxMenuItem *) x));
54175 }
54176 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54177 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54178 }
54179 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54180 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54181 }
54182 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54183 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54184 }
54185 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54186 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54187 }
54188 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54189 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54190 }
54191 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54192 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54193 }
54194 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54195 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54196 }
54197 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54198 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54199 }
54200 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54201 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54202 }
54203 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54204 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54205 }
54206 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54207 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54208 }
54209 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54210 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54211 }
54212 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54213 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54214 }
54215 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54216 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54217 }
54218 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54219 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54220 }
54221 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54222 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54223 }
54224 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54225 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54226 }
54227 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54228 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54229 }
54230 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54231 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54232 }
54233 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54234 return (void *)((wxObject *) ((wxImageHandler *) x));
54235 }
54236 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54237 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54238 }
54239 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54240 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54241 }
54242 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54243 return (void *)((wxObject *) ((wxEvtHandler *) x));
54244 }
54245 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54246 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54247 }
54248 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54249 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54250 }
54251 static void *_p_wxImageTo_p_wxObject(void *x) {
54252 return (void *)((wxObject *) ((wxImage *) x));
54253 }
54254 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54255 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54256 }
54257 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54258 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54259 }
54260 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54261 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54262 }
54263 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54264 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54265 }
54266 static void *_p_wxWindowTo_p_wxObject(void *x) {
54267 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54268 }
54269 static void *_p_wxMenuTo_p_wxObject(void *x) {
54270 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54271 }
54272 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54273 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54274 }
54275 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54276 return (void *)((wxObject *) ((wxFileSystem *) x));
54277 }
54278 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54279 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54280 }
54281 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54282 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54283 }
54284 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54285 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54286 }
54287 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54288 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54289 }
54290 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54291 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54292 }
54293 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54294 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54295 }
54296 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54297 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54298 }
54299 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54300 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54301 }
54302 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54303 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54304 }
54305 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54306 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54307 }
54308 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54310 }
54311 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54312 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54313 }
54314 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54315 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54316 }
54317 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54318 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54319 }
54320 static void *_p_wxControlTo_p_wxWindow(void *x) {
54321 return (void *)((wxWindow *) ((wxControl *) x));
54322 }
54323 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54324 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54325 }
54326 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54327 return (void *)((wxWindow *) ((wxMenuBar *) x));
54328 }
54329 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54330 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54331 }
54332 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54333 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54334 }
54335 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54336 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54337 }
54338 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54339 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54340 }
54341 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54342 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54343 }
54344 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54345 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54346 }
54347 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54348 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54349 }
54350 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54351 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54352 }
54353 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54354 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54355 }
54356 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54357 return (void *)((wxValidator *) ((wxPyValidator *) x));
54358 }
54359 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54361 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};
54362 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54488
54489 static swig_type_info *swig_type_initial[] = {
54490 &_swigt__p_buffer,
54491 &_swigt__p_char,
54492 &_swigt__p_form_ops_t,
54493 &_swigt__p_int,
54494 &_swigt__p_long,
54495 &_swigt__p_unsigned_char,
54496 &_swigt__p_unsigned_int,
54497 &_swigt__p_unsigned_long,
54498 &_swigt__p_wxANIHandler,
54499 &_swigt__p_wxAcceleratorEntry,
54500 &_swigt__p_wxAcceleratorTable,
54501 &_swigt__p_wxActivateEvent,
54502 &_swigt__p_wxAppTraits,
54503 &_swigt__p_wxArrayString,
54504 &_swigt__p_wxBMPHandler,
54505 &_swigt__p_wxBitmap,
54506 &_swigt__p_wxBoxSizer,
54507 &_swigt__p_wxButton,
54508 &_swigt__p_wxCURHandler,
54509 &_swigt__p_wxCaret,
54510 &_swigt__p_wxChildFocusEvent,
54511 &_swigt__p_wxCloseEvent,
54512 &_swigt__p_wxColour,
54513 &_swigt__p_wxCommandEvent,
54514 &_swigt__p_wxContextMenuEvent,
54515 &_swigt__p_wxControl,
54516 &_swigt__p_wxControlWithItems,
54517 &_swigt__p_wxCursor,
54518 &_swigt__p_wxDC,
54519 &_swigt__p_wxDateEvent,
54520 &_swigt__p_wxDateTime,
54521 &_swigt__p_wxDisplayChangedEvent,
54522 &_swigt__p_wxDropFilesEvent,
54523 &_swigt__p_wxDuplexMode,
54524 &_swigt__p_wxEraseEvent,
54525 &_swigt__p_wxEvent,
54526 &_swigt__p_wxEventLoop,
54527 &_swigt__p_wxEventLoopActivator,
54528 &_swigt__p_wxEvtHandler,
54529 &_swigt__p_wxFSFile,
54530 &_swigt__p_wxFileSystem,
54531 &_swigt__p_wxFileSystemHandler,
54532 &_swigt__p_wxFlexGridSizer,
54533 &_swigt__p_wxFocusEvent,
54534 &_swigt__p_wxFont,
54535 &_swigt__p_wxFrame,
54536 &_swigt__p_wxGBPosition,
54537 &_swigt__p_wxGBSizerItem,
54538 &_swigt__p_wxGBSpan,
54539 &_swigt__p_wxGIFHandler,
54540 &_swigt__p_wxGridBagSizer,
54541 &_swigt__p_wxGridSizer,
54542 &_swigt__p_wxICOHandler,
54543 &_swigt__p_wxIconizeEvent,
54544 &_swigt__p_wxIdleEvent,
54545 &_swigt__p_wxImage,
54546 &_swigt__p_wxImageHandler,
54547 &_swigt__p_wxImageHistogram,
54548 &_swigt__p_wxImage_HSVValue,
54549 &_swigt__p_wxImage_RGBValue,
54550 &_swigt__p_wxIndividualLayoutConstraint,
54551 &_swigt__p_wxInitDialogEvent,
54552 &_swigt__p_wxInputStream,
54553 &_swigt__p_wxInternetFSHandler,
54554 &_swigt__p_wxItemContainer,
54555 &_swigt__p_wxJPEGHandler,
54556 &_swigt__p_wxKeyEvent,
54557 &_swigt__p_wxLayoutConstraints,
54558 &_swigt__p_wxMaximizeEvent,
54559 &_swigt__p_wxMemoryFSHandler,
54560 &_swigt__p_wxMenu,
54561 &_swigt__p_wxMenuBar,
54562 &_swigt__p_wxMenuBarBase,
54563 &_swigt__p_wxMenuEvent,
54564 &_swigt__p_wxMenuItem,
54565 &_swigt__p_wxMouseCaptureChangedEvent,
54566 &_swigt__p_wxMouseEvent,
54567 &_swigt__p_wxMoveEvent,
54568 &_swigt__p_wxNavigationKeyEvent,
54569 &_swigt__p_wxNcPaintEvent,
54570 &_swigt__p_wxNotifyEvent,
54571 &_swigt__p_wxObject,
54572 &_swigt__p_wxOutputStream,
54573 &_swigt__p_wxPCXHandler,
54574 &_swigt__p_wxPNGHandler,
54575 &_swigt__p_wxPNMHandler,
54576 &_swigt__p_wxPaintEvent,
54577 &_swigt__p_wxPaletteChangedEvent,
54578 &_swigt__p_wxPaperSize,
54579 &_swigt__p_wxPoint,
54580 &_swigt__p_wxPoint2D,
54581 &_swigt__p_wxPropagateOnce,
54582 &_swigt__p_wxPropagationDisabler,
54583 &_swigt__p_wxPyApp,
54584 &_swigt__p_wxPyCommandEvent,
54585 &_swigt__p_wxPyDropTarget,
54586 &_swigt__p_wxPyEvent,
54587 &_swigt__p_wxPyFileSystemHandler,
54588 &_swigt__p_wxPyImageHandler,
54589 &_swigt__p_wxPyInputStream,
54590 &_swigt__p_wxPySizer,
54591 &_swigt__p_wxPyValidator,
54592 &_swigt__p_wxQuantize,
54593 &_swigt__p_wxQueryNewPaletteEvent,
54594 &_swigt__p_wxRealPoint,
54595 &_swigt__p_wxRect,
54596 &_swigt__p_wxRegion,
54597 &_swigt__p_wxScrollEvent,
54598 &_swigt__p_wxScrollWinEvent,
54599 &_swigt__p_wxSetCursorEvent,
54600 &_swigt__p_wxShowEvent,
54601 &_swigt__p_wxSize,
54602 &_swigt__p_wxSizeEvent,
54603 &_swigt__p_wxSizer,
54604 &_swigt__p_wxSizerItem,
54605 &_swigt__p_wxStaticBox,
54606 &_swigt__p_wxStaticBoxSizer,
54607 &_swigt__p_wxStdDialogButtonSizer,
54608 &_swigt__p_wxSysColourChangedEvent,
54609 &_swigt__p_wxTIFFHandler,
54610 &_swigt__p_wxToolTip,
54611 &_swigt__p_wxUpdateUIEvent,
54612 &_swigt__p_wxValidator,
54613 &_swigt__p_wxVisualAttributes,
54614 &_swigt__p_wxWindow,
54615 &_swigt__p_wxWindowCreateEvent,
54616 &_swigt__p_wxWindowDestroyEvent,
54617 &_swigt__p_wxXPMHandler,
54618 &_swigt__p_wxZipFSHandler,
54619 };
54620
54621 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54628 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54629 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54630 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54635 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}};
54636 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54637 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}};
54638 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54639 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}};
54640 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54642 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54644 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}};
54645 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54646 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}};
54647 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54656 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}};
54657 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54659 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}};
54660 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54662 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}};
54663 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}};
54664 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54672 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}};
54673 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}};
54674 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54677 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}};
54678 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54684 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54685 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}};
54686 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54690 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54691 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54692 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54702 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}};
54703 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54710 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54711 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54712 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54713 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54714 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54715 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54716 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54717 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54718 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54719 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54721 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54722 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54733 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54734 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}};
54735 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}};
54736 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54737 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54738 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54739 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54740 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54741 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54743 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}};
54744 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54745 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}};
54746 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54747 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54748 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54749 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54750
54751 static swig_cast_info *swig_cast_initial[] = {
54752 _swigc__p_buffer,
54753 _swigc__p_char,
54754 _swigc__p_form_ops_t,
54755 _swigc__p_int,
54756 _swigc__p_long,
54757 _swigc__p_unsigned_char,
54758 _swigc__p_unsigned_int,
54759 _swigc__p_unsigned_long,
54760 _swigc__p_wxANIHandler,
54761 _swigc__p_wxAcceleratorEntry,
54762 _swigc__p_wxAcceleratorTable,
54763 _swigc__p_wxActivateEvent,
54764 _swigc__p_wxAppTraits,
54765 _swigc__p_wxArrayString,
54766 _swigc__p_wxBMPHandler,
54767 _swigc__p_wxBitmap,
54768 _swigc__p_wxBoxSizer,
54769 _swigc__p_wxButton,
54770 _swigc__p_wxCURHandler,
54771 _swigc__p_wxCaret,
54772 _swigc__p_wxChildFocusEvent,
54773 _swigc__p_wxCloseEvent,
54774 _swigc__p_wxColour,
54775 _swigc__p_wxCommandEvent,
54776 _swigc__p_wxContextMenuEvent,
54777 _swigc__p_wxControl,
54778 _swigc__p_wxControlWithItems,
54779 _swigc__p_wxCursor,
54780 _swigc__p_wxDC,
54781 _swigc__p_wxDateEvent,
54782 _swigc__p_wxDateTime,
54783 _swigc__p_wxDisplayChangedEvent,
54784 _swigc__p_wxDropFilesEvent,
54785 _swigc__p_wxDuplexMode,
54786 _swigc__p_wxEraseEvent,
54787 _swigc__p_wxEvent,
54788 _swigc__p_wxEventLoop,
54789 _swigc__p_wxEventLoopActivator,
54790 _swigc__p_wxEvtHandler,
54791 _swigc__p_wxFSFile,
54792 _swigc__p_wxFileSystem,
54793 _swigc__p_wxFileSystemHandler,
54794 _swigc__p_wxFlexGridSizer,
54795 _swigc__p_wxFocusEvent,
54796 _swigc__p_wxFont,
54797 _swigc__p_wxFrame,
54798 _swigc__p_wxGBPosition,
54799 _swigc__p_wxGBSizerItem,
54800 _swigc__p_wxGBSpan,
54801 _swigc__p_wxGIFHandler,
54802 _swigc__p_wxGridBagSizer,
54803 _swigc__p_wxGridSizer,
54804 _swigc__p_wxICOHandler,
54805 _swigc__p_wxIconizeEvent,
54806 _swigc__p_wxIdleEvent,
54807 _swigc__p_wxImage,
54808 _swigc__p_wxImageHandler,
54809 _swigc__p_wxImageHistogram,
54810 _swigc__p_wxImage_HSVValue,
54811 _swigc__p_wxImage_RGBValue,
54812 _swigc__p_wxIndividualLayoutConstraint,
54813 _swigc__p_wxInitDialogEvent,
54814 _swigc__p_wxInputStream,
54815 _swigc__p_wxInternetFSHandler,
54816 _swigc__p_wxItemContainer,
54817 _swigc__p_wxJPEGHandler,
54818 _swigc__p_wxKeyEvent,
54819 _swigc__p_wxLayoutConstraints,
54820 _swigc__p_wxMaximizeEvent,
54821 _swigc__p_wxMemoryFSHandler,
54822 _swigc__p_wxMenu,
54823 _swigc__p_wxMenuBar,
54824 _swigc__p_wxMenuBarBase,
54825 _swigc__p_wxMenuEvent,
54826 _swigc__p_wxMenuItem,
54827 _swigc__p_wxMouseCaptureChangedEvent,
54828 _swigc__p_wxMouseEvent,
54829 _swigc__p_wxMoveEvent,
54830 _swigc__p_wxNavigationKeyEvent,
54831 _swigc__p_wxNcPaintEvent,
54832 _swigc__p_wxNotifyEvent,
54833 _swigc__p_wxObject,
54834 _swigc__p_wxOutputStream,
54835 _swigc__p_wxPCXHandler,
54836 _swigc__p_wxPNGHandler,
54837 _swigc__p_wxPNMHandler,
54838 _swigc__p_wxPaintEvent,
54839 _swigc__p_wxPaletteChangedEvent,
54840 _swigc__p_wxPaperSize,
54841 _swigc__p_wxPoint,
54842 _swigc__p_wxPoint2D,
54843 _swigc__p_wxPropagateOnce,
54844 _swigc__p_wxPropagationDisabler,
54845 _swigc__p_wxPyApp,
54846 _swigc__p_wxPyCommandEvent,
54847 _swigc__p_wxPyDropTarget,
54848 _swigc__p_wxPyEvent,
54849 _swigc__p_wxPyFileSystemHandler,
54850 _swigc__p_wxPyImageHandler,
54851 _swigc__p_wxPyInputStream,
54852 _swigc__p_wxPySizer,
54853 _swigc__p_wxPyValidator,
54854 _swigc__p_wxQuantize,
54855 _swigc__p_wxQueryNewPaletteEvent,
54856 _swigc__p_wxRealPoint,
54857 _swigc__p_wxRect,
54858 _swigc__p_wxRegion,
54859 _swigc__p_wxScrollEvent,
54860 _swigc__p_wxScrollWinEvent,
54861 _swigc__p_wxSetCursorEvent,
54862 _swigc__p_wxShowEvent,
54863 _swigc__p_wxSize,
54864 _swigc__p_wxSizeEvent,
54865 _swigc__p_wxSizer,
54866 _swigc__p_wxSizerItem,
54867 _swigc__p_wxStaticBox,
54868 _swigc__p_wxStaticBoxSizer,
54869 _swigc__p_wxStdDialogButtonSizer,
54870 _swigc__p_wxSysColourChangedEvent,
54871 _swigc__p_wxTIFFHandler,
54872 _swigc__p_wxToolTip,
54873 _swigc__p_wxUpdateUIEvent,
54874 _swigc__p_wxValidator,
54875 _swigc__p_wxVisualAttributes,
54876 _swigc__p_wxWindow,
54877 _swigc__p_wxWindowCreateEvent,
54878 _swigc__p_wxWindowDestroyEvent,
54879 _swigc__p_wxXPMHandler,
54880 _swigc__p_wxZipFSHandler,
54881 };
54882
54883
54884 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54885
54886 static swig_const_info swig_const_table[] = {
54887 {0, 0, 0, 0.0, 0, 0}};
54888
54889 #ifdef __cplusplus
54890 }
54891 #endif
54892 /* -----------------------------------------------------------------------------
54893 * Type initialization:
54894 * This problem is tough by the requirement that no dynamic
54895 * memory is used. Also, since swig_type_info structures store pointers to
54896 * swig_cast_info structures and swig_cast_info structures store pointers back
54897 * to swig_type_info structures, we need some lookup code at initialization.
54898 * The idea is that swig generates all the structures that are needed.
54899 * The runtime then collects these partially filled structures.
54900 * The SWIG_InitializeModule function takes these initial arrays out of
54901 * swig_module, and does all the lookup, filling in the swig_module.types
54902 * array with the correct data and linking the correct swig_cast_info
54903 * structures together.
54904 *
54905 * The generated swig_type_info structures are assigned staticly to an initial
54906 * array. We just loop though that array, and handle each type individually.
54907 * First we lookup if this type has been already loaded, and if so, use the
54908 * loaded structure instead of the generated one. Then we have to fill in the
54909 * cast linked list. The cast data is initially stored in something like a
54910 * two-dimensional array. Each row corresponds to a type (there are the same
54911 * number of rows as there are in the swig_type_initial array). Each entry in
54912 * a column is one of the swig_cast_info structures for that type.
54913 * The cast_initial array is actually an array of arrays, because each row has
54914 * a variable number of columns. So to actually build the cast linked list,
54915 * we find the array of casts associated with the type, and loop through it
54916 * adding the casts to the list. The one last trick we need to do is making
54917 * sure the type pointer in the swig_cast_info struct is correct.
54918 *
54919 * First off, we lookup the cast->type name to see if it is already loaded.
54920 * There are three cases to handle:
54921 * 1) If the cast->type has already been loaded AND the type we are adding
54922 * casting info to has not been loaded (it is in this module), THEN we
54923 * replace the cast->type pointer with the type pointer that has already
54924 * been loaded.
54925 * 2) If BOTH types (the one we are adding casting info to, and the
54926 * cast->type) are loaded, THEN the cast info has already been loaded by
54927 * the previous module so we just ignore it.
54928 * 3) Finally, if cast->type has not already been loaded, then we add that
54929 * swig_cast_info to the linked list (because the cast->type) pointer will
54930 * be correct.
54931 * ----------------------------------------------------------------------------- */
54932
54933 #ifdef __cplusplus
54934 extern "C" {
54935 #if 0
54936 } /* c-mode */
54937 #endif
54938 #endif
54939
54940 #if 0
54941 #define SWIGRUNTIME_DEBUG
54942 #endif
54943
54944 SWIGRUNTIME void
54945 SWIG_InitializeModule(void *clientdata) {
54946 size_t i;
54947 swig_module_info *module_head;
54948 static int init_run = 0;
54949
54950 clientdata = clientdata;
54951
54952 if (init_run) return;
54953 init_run = 1;
54954
54955 /* Initialize the swig_module */
54956 swig_module.type_initial = swig_type_initial;
54957 swig_module.cast_initial = swig_cast_initial;
54958
54959 /* Try and load any already created modules */
54960 module_head = SWIG_GetModule(clientdata);
54961 if (module_head) {
54962 swig_module.next = module_head->next;
54963 module_head->next = &swig_module;
54964 } else {
54965 /* This is the first module loaded */
54966 swig_module.next = &swig_module;
54967 SWIG_SetModule(clientdata, &swig_module);
54968 }
54969
54970 /* Now work on filling in swig_module.types */
54971 #ifdef SWIGRUNTIME_DEBUG
54972 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54973 #endif
54974 for (i = 0; i < swig_module.size; ++i) {
54975 swig_type_info *type = 0;
54976 swig_type_info *ret;
54977 swig_cast_info *cast;
54978
54979 #ifdef SWIGRUNTIME_DEBUG
54980 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54981 #endif
54982
54983 /* if there is another module already loaded */
54984 if (swig_module.next != &swig_module) {
54985 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54986 }
54987 if (type) {
54988 /* Overwrite clientdata field */
54989 #ifdef SWIGRUNTIME_DEBUG
54990 printf("SWIG_InitializeModule: found type %s\n", type->name);
54991 #endif
54992 if (swig_module.type_initial[i]->clientdata) {
54993 type->clientdata = swig_module.type_initial[i]->clientdata;
54994 #ifdef SWIGRUNTIME_DEBUG
54995 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54996 #endif
54997 }
54998 } else {
54999 type = swig_module.type_initial[i];
55000 }
55001
55002 /* Insert casting types */
55003 cast = swig_module.cast_initial[i];
55004 while (cast->type) {
55005 /* Don't need to add information already in the list */
55006 ret = 0;
55007 #ifdef SWIGRUNTIME_DEBUG
55008 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55009 #endif
55010 if (swig_module.next != &swig_module) {
55011 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55012 #ifdef SWIGRUNTIME_DEBUG
55013 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55014 #endif
55015 }
55016 if (ret) {
55017 if (type == swig_module.type_initial[i]) {
55018 #ifdef SWIGRUNTIME_DEBUG
55019 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55020 #endif
55021 cast->type = ret;
55022 ret = 0;
55023 } else {
55024 /* Check for casting already in the list */
55025 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55026 #ifdef SWIGRUNTIME_DEBUG
55027 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55028 #endif
55029 if (!ocast) ret = 0;
55030 }
55031 }
55032
55033 if (!ret) {
55034 #ifdef SWIGRUNTIME_DEBUG
55035 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55036 #endif
55037 if (type->cast) {
55038 type->cast->prev = cast;
55039 cast->next = type->cast;
55040 }
55041 type->cast = cast;
55042 }
55043 cast++;
55044 }
55045 /* Set entry in modules->types array equal to the type */
55046 swig_module.types[i] = type;
55047 }
55048 swig_module.types[i] = 0;
55049
55050 #ifdef SWIGRUNTIME_DEBUG
55051 printf("**** SWIG_InitializeModule: Cast List ******\n");
55052 for (i = 0; i < swig_module.size; ++i) {
55053 int j = 0;
55054 swig_cast_info *cast = swig_module.cast_initial[i];
55055 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55056 while (cast->type) {
55057 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55058 cast++;
55059 ++j;
55060 }
55061 printf("---- Total casts: %d\n",j);
55062 }
55063 printf("**** SWIG_InitializeModule: Cast List ******\n");
55064 #endif
55065 }
55066
55067 /* This function will propagate the clientdata field of type to
55068 * any new swig_type_info structures that have been added into the list
55069 * of equivalent types. It is like calling
55070 * SWIG_TypeClientData(type, clientdata) a second time.
55071 */
55072 SWIGRUNTIME void
55073 SWIG_PropagateClientData(void) {
55074 size_t i;
55075 swig_cast_info *equiv;
55076 static int init_run = 0;
55077
55078 if (init_run) return;
55079 init_run = 1;
55080
55081 for (i = 0; i < swig_module.size; i++) {
55082 if (swig_module.types[i]->clientdata) {
55083 equiv = swig_module.types[i]->cast;
55084 while (equiv) {
55085 if (!equiv->converter) {
55086 if (equiv->type && !equiv->type->clientdata)
55087 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55088 }
55089 equiv = equiv->next;
55090 }
55091 }
55092 }
55093 }
55094
55095 #ifdef __cplusplus
55096 #if 0
55097 {
55098 /* c-mode */
55099 #endif
55100 }
55101 #endif
55102
55103
55104
55105 #ifdef __cplusplus
55106 extern "C" {
55107 #endif
55108
55109 /* Python-specific SWIG API */
55110 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55111 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55112 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55113
55114 /* -----------------------------------------------------------------------------
55115 * global variable support code.
55116 * ----------------------------------------------------------------------------- */
55117
55118 typedef struct swig_globalvar {
55119 char *name; /* Name of global variable */
55120 PyObject *(*get_attr)(void); /* Return the current value */
55121 int (*set_attr)(PyObject *); /* Set the value */
55122 struct swig_globalvar *next;
55123 } swig_globalvar;
55124
55125 typedef struct swig_varlinkobject {
55126 PyObject_HEAD
55127 swig_globalvar *vars;
55128 } swig_varlinkobject;
55129
55130 SWIGINTERN PyObject *
55131 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55132 return PyString_FromString("<Swig global variables>");
55133 }
55134
55135 SWIGINTERN PyObject *
55136 swig_varlink_str(swig_varlinkobject *v) {
55137 PyObject *str = PyString_FromString("(");
55138 swig_globalvar *var;
55139 for (var = v->vars; var; var=var->next) {
55140 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55141 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55142 }
55143 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55144 return str;
55145 }
55146
55147 SWIGINTERN int
55148 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55149 PyObject *str = swig_varlink_str(v);
55150 fprintf(fp,"Swig global variables ");
55151 fprintf(fp,"%s\n", PyString_AsString(str));
55152 Py_DECREF(str);
55153 return 0;
55154 }
55155
55156 SWIGINTERN void
55157 swig_varlink_dealloc(swig_varlinkobject *v) {
55158 swig_globalvar *var = v->vars;
55159 while (var) {
55160 swig_globalvar *n = var->next;
55161 free(var->name);
55162 free(var);
55163 var = n;
55164 }
55165 }
55166
55167 SWIGINTERN PyObject *
55168 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55169 PyObject *res = NULL;
55170 swig_globalvar *var = v->vars;
55171 while (var) {
55172 if (strcmp(var->name,n) == 0) {
55173 res = (*var->get_attr)();
55174 break;
55175 }
55176 var = var->next;
55177 }
55178 if (res == NULL && !PyErr_Occurred()) {
55179 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55180 }
55181 return res;
55182 }
55183
55184 SWIGINTERN int
55185 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55186 int res = 1;
55187 swig_globalvar *var = v->vars;
55188 while (var) {
55189 if (strcmp(var->name,n) == 0) {
55190 res = (*var->set_attr)(p);
55191 break;
55192 }
55193 var = var->next;
55194 }
55195 if (res == 1 && !PyErr_Occurred()) {
55196 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55197 }
55198 return res;
55199 }
55200
55201 SWIGINTERN PyTypeObject*
55202 swig_varlink_type(void) {
55203 static char varlink__doc__[] = "Swig var link object";
55204 static PyTypeObject varlink_type;
55205 static int type_init = 0;
55206 if (!type_init) {
55207 const PyTypeObject tmp
55208 = {
55209 PyObject_HEAD_INIT(NULL)
55210 0, /* Number of items in variable part (ob_size) */
55211 (char *)"swigvarlink", /* Type name (tp_name) */
55212 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55213 0, /* Itemsize (tp_itemsize) */
55214 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55215 (printfunc) swig_varlink_print, /* Print (tp_print) */
55216 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55217 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55218 0, /* tp_compare */
55219 (reprfunc) swig_varlink_repr, /* tp_repr */
55220 0, /* tp_as_number */
55221 0, /* tp_as_sequence */
55222 0, /* tp_as_mapping */
55223 0, /* tp_hash */
55224 0, /* tp_call */
55225 (reprfunc)swig_varlink_str, /* tp_str */
55226 0, /* tp_getattro */
55227 0, /* tp_setattro */
55228 0, /* tp_as_buffer */
55229 0, /* tp_flags */
55230 varlink__doc__, /* tp_doc */
55231 0, /* tp_traverse */
55232 0, /* tp_clear */
55233 0, /* tp_richcompare */
55234 0, /* tp_weaklistoffset */
55235 #if PY_VERSION_HEX >= 0x02020000
55236 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55237 #endif
55238 #if PY_VERSION_HEX >= 0x02030000
55239 0, /* tp_del */
55240 #endif
55241 #ifdef COUNT_ALLOCS
55242 0,0,0,0 /* tp_alloc -> tp_next */
55243 #endif
55244 };
55245 varlink_type = tmp;
55246 varlink_type.ob_type = &PyType_Type;
55247 type_init = 1;
55248 }
55249 return &varlink_type;
55250 }
55251
55252 /* Create a variable linking object for use later */
55253 SWIGINTERN PyObject *
55254 SWIG_Python_newvarlink(void) {
55255 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55256 if (result) {
55257 result->vars = 0;
55258 }
55259 return ((PyObject*) result);
55260 }
55261
55262 SWIGINTERN void
55263 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55264 swig_varlinkobject *v = (swig_varlinkobject *) p;
55265 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55266 if (gv) {
55267 size_t size = strlen(name)+1;
55268 gv->name = (char *)malloc(size);
55269 if (gv->name) {
55270 strncpy(gv->name,name,size);
55271 gv->get_attr = get_attr;
55272 gv->set_attr = set_attr;
55273 gv->next = v->vars;
55274 }
55275 }
55276 v->vars = gv;
55277 }
55278
55279 SWIGINTERN PyObject *
55280 SWIG_globals() {
55281 static PyObject *_SWIG_globals = 0;
55282 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55283 return _SWIG_globals;
55284 }
55285
55286 /* -----------------------------------------------------------------------------
55287 * constants/methods manipulation
55288 * ----------------------------------------------------------------------------- */
55289
55290 /* Install Constants */
55291 SWIGINTERN void
55292 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55293 PyObject *obj = 0;
55294 size_t i;
55295 for (i = 0; constants[i].type; ++i) {
55296 switch(constants[i].type) {
55297 case SWIG_PY_POINTER:
55298 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55299 break;
55300 case SWIG_PY_BINARY:
55301 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55302 break;
55303 default:
55304 obj = 0;
55305 break;
55306 }
55307 if (obj) {
55308 PyDict_SetItemString(d, constants[i].name, obj);
55309 Py_DECREF(obj);
55310 }
55311 }
55312 }
55313
55314 /* -----------------------------------------------------------------------------*/
55315 /* Fix SwigMethods to carry the callback ptrs when needed */
55316 /* -----------------------------------------------------------------------------*/
55317
55318 SWIGINTERN void
55319 SWIG_Python_FixMethods(PyMethodDef *methods,
55320 swig_const_info *const_table,
55321 swig_type_info **types,
55322 swig_type_info **types_initial) {
55323 size_t i;
55324 for (i = 0; methods[i].ml_name; ++i) {
55325 char *c = methods[i].ml_doc;
55326 if (c && (c = strstr(c, "swig_ptr: "))) {
55327 int j;
55328 swig_const_info *ci = 0;
55329 char *name = c + 10;
55330 for (j = 0; const_table[j].type; ++j) {
55331 if (strncmp(const_table[j].name, name,
55332 strlen(const_table[j].name)) == 0) {
55333 ci = &(const_table[j]);
55334 break;
55335 }
55336 }
55337 if (ci) {
55338 size_t shift = (ci->ptype) - types;
55339 swig_type_info *ty = types_initial[shift];
55340 size_t ldoc = (c - methods[i].ml_doc);
55341 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55342 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55343 if (ndoc) {
55344 char *buff = ndoc;
55345 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55346 if (ptr) {
55347 strncpy(buff, methods[i].ml_doc, ldoc);
55348 buff += ldoc;
55349 strncpy(buff, "swig_ptr: ", 10);
55350 buff += 10;
55351 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55352 methods[i].ml_doc = ndoc;
55353 }
55354 }
55355 }
55356 }
55357 }
55358 }
55359
55360 #ifdef __cplusplus
55361 }
55362 #endif
55363
55364 /* -----------------------------------------------------------------------------*
55365 * Partial Init method
55366 * -----------------------------------------------------------------------------*/
55367
55368 #ifdef __cplusplus
55369 extern "C"
55370 #endif
55371 SWIGEXPORT void SWIG_init(void) {
55372 PyObject *m, *d;
55373
55374 /* Fix SwigMethods to carry the callback ptrs when needed */
55375 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55376
55377 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55378 d = PyModule_GetDict(m);
55379
55380 SWIG_InitializeModule(0);
55381 SWIG_InstallConstants(d,swig_const_table);
55382
55383
55384
55385 #ifndef wxPyUSE_EXPORT
55386 // Make our API structure a CObject so other modules can import it
55387 // from this module.
55388 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55389 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55390 Py_XDECREF(cobj);
55391 #endif
55392
55393 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55394 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55395 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55396 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55397 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55398 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55399 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55400 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55401 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55402 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55403 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55404 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55405 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55406 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55407 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55408 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55409 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55410 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55411 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55412 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55413 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55414 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55415 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55416 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55417 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55418 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55419 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55420 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55421 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55422 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55423 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55424 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55425 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55426 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55427 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55428 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55429 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55430 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55431 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55432 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55433 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55434 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55435 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55436 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55437 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55438 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55439 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55440 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55441 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55442 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55443 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55444 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55445 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55446 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55447 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55448 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55449 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55450 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55451 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55452 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55453 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55454 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55455 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55456 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55457 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55458 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55459 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55460 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55461 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55462 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55463 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55464 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55465 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55466 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55467 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55468 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55469 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55470 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55471 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55472 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55473 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55474 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55475 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55476 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55477 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55478 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55479 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55480 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55481 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55482 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55483 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55484 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55485 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55486 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55487 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55488 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55489 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55490 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55491 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55492 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55493 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55494 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55495 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55496 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55497 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55498 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55499 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55500 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55501 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55502 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55503 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55504 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55505 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55506 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55507 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55508 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55509 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55510 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55511 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55512 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55513 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55514 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55515 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55516 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55517 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55518 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55519 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55520 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55521 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55522 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55523 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55524 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55525 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55526 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55527 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55528 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55529 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55530 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55531 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55532 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55533 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55534 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55535 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55536 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55537 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55538 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55539 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55540 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55541 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55542 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55543 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55544 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55545 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55546 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55547 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55548 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55549 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55550 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55551 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55552 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55553 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55554 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55555 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55556 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55557 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55558 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55559 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55560 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55561 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55562 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55563 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55564 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55565 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55566 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55567 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55568 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55569 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55570 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55571 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55572 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55573 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55574 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55575 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55576 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55577 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55578 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55579 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55580 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55581 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55582 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55583 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55584 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55585 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55586 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55587 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55588 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55589 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55590 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55591 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55592 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55593 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55594 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55595 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55596 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55597 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55598 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55599 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55600 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55601 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55602 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55603 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55604 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55605 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55606 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55607 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55608 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55609 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55610 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55611 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55612 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55613 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55614 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55615 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55616 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55617 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55618 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55619 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55620 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55621 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55622 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55623 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55624 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55625 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55626 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55627 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55628 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55629 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55630 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55631 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55632 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55633 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55634 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55635 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55636 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55637 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55638 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55639 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55640 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55641 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55642 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55643 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55644 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55645 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55646 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55647 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55648 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55649 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55650 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55651 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55652 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55653 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55654 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55655 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55656 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55657 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55658 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55659 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55660 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55661 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55662 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55663 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55664 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55665 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55666 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55667 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55668 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55669 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55670 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55671 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55672 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55673 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55674 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55675 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55676 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55677 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55678 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55679 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55680 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55681 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55682 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55683 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55684 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55685 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55686 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55687 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55688 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55689 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55690 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55691 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55692 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55693 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55694 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55695 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55696 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55697 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55698 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55699 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55700 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55701 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55702 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55703 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55704 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55705 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55706 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55707 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55708 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55709 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55710 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55711 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55712 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55713 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55714 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55715 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55716 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55717 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55718 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55719 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55720 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55721 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55722 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55723 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55724 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55725 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55726 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55727 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55728 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55729 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55730 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55731 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55732 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55733 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55734 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55735 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55736 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55737 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55738 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55739 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55740 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55741 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55742 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55743 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55744 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55745 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55746 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55747 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55748 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55749 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55750 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55751 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55752 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55753 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55754 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55755 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55756 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55757 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55758 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55759 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55760 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55761 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55762 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55763 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55764 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55765 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55766 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55767 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55768 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55769 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55770 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55771 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55772 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55773 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55774 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55775 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55776 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55777 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55778 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55779 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55780 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55781 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55782 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55783 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55784 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55785 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55786 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55787 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55788 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55789 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55790 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55791 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55792 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55793 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55794 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55795 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55796 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55797 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55798 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55799 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55800 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55801 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55807 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55808 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55809 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55810 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55811 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55812 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55813 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55814 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55815 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55816 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55817 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55818 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55819 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55820 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55821 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55822 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55823 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55824 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55825 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55826 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55827 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55828 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55829 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55830 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55831 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55832 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55833 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55834 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55835 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55836 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55837 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55838 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55839 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55840 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55841 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55842 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55843 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55844 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55845 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55846 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55847 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55848 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55849 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55850 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55851 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55852 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55853 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55854 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55855 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55856 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55857 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55858 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55859 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55860 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55861 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55862 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55863 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55864 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55865 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55866 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55867 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55868 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55869 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55870 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55871 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55872 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55873 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55874 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55875 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55876 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55877 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55878 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55879 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55880 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55881 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55882 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55883 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55884 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55885 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55886 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55887 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55888 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55889 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55890 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55891 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55892 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55893 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55894 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55895 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55896 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55897 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55898 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55899 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55900 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55901 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55902 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55903 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55904 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55905 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55906 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55907 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55908 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55909 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55910 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55911 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55912 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55913 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55914 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55915 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55916 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55917 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55918 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55919 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55920 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55921 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55922 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55923 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55924 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55925 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55926 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55927 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55928 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55929 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55930 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55931 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55932 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55933 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55934 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55935 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55936 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55937 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55938 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55939 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55940 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55941 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55942 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55943 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55944 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55945 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55946 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55947 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55948 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55949 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55950 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55951 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55952 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55953 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55954 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55955 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55956 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55957 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55958 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55959 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55960 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55961 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55962 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55963 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55964 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55965 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55966 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55967 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55968 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55969 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55970 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55971 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55972 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55973 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55974 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55975 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55976 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55977 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55978 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55979 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55980 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55981 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55982 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55983 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55984 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55985 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55986 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55987 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55988 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55989 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55990 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55991 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55992 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55993 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55994 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55995 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55996 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55997 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55998 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55999 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56000 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56001 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56002 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56003 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56004 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56005 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56006 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56007 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56009 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56010 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56011 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56012 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56013 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56014 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56015 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56016 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56017 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56018 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56019 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56020 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56021 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56022 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56023 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56024 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56025 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56026 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56027 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56028 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56029 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56030 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56031 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56032 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56033 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56034 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56035 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56036 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56037 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56038 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56039 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56040 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56041 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56042 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56043 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56044 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56045 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56046 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56047 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56048 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56049 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56050 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56051 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56052 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56053 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56054 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56055 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56056 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56057 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56058 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56059 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56060 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56061 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56062 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56063 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56064
56065 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56066
56067
56068 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56069
56070 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56071 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56072 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56073 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56074 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56075 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56076 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56077 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56078 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56079 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56080 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56081 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56082 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56083 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56084 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56085 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56086 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56087 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56088 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56089 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56090 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56091 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56092 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56093 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56094 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56095 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56096 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56097 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56098 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56099 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56100 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56101 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56102 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56103 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56104 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56105 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56106 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56107 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56108 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56109 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56110 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56111 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56112 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56113 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56114 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56115 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56116 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56117 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56118 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56119 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56120 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56121 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56122 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56123 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56124 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56125 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56126 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56127 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56128 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56129 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56130 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56131 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56132 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56133 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56134 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56135 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56136 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56137 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56138 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56139 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56140 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56141 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56142 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56143 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56144 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56145 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56146 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56147 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56148 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56149 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56150 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56151 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56152 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56153 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56154 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56155 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56156 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56157 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56158 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56159 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56160 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56161 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56162 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56163 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56164 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56165 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56166 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56167 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56168 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56169 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56170 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56171 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56172 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56173 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56174 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56175 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56176 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56177 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56178 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56179 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56180 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56181 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56182 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56183 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56184 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56185 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56186 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56187 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56188 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56189 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56190 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56191 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56192 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56193 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56194 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56195 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56196 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56197 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56198 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56199 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56200 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56201 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56202 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56203 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56204 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56205 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56206 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56207 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56208 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56209 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56210 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56211 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56212 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56213 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56214 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56215 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56216 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56217 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56218 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56219 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56220 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56221 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56222 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56223 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56224 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56225 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56226 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56227 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56228 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56229 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56230 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56231 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56232 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56233 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56234 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56235 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56236 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56237 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56238 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56239 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56240 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56241 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56242 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56243 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56244 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56245 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56246 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56247 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56248 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56249 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56250 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56251 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56252 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56253 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56254 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56255 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56256 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56257 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56258 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56259 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56260 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56261 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56262 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56263 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56264 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56265 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56266 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56267 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56268 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56269 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56270 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56271 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56272 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56273 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56274
56275 // Initialize threading, some globals and such
56276 __wxPyPreStart(d);
56277
56278
56279 // Although these are defined in __version__ they need to be here too so
56280 // that an assert can be done to ensure that the wxPython and the wxWindows
56281 // versions match.
56282 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56283 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56284 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56285
56286 }
56287
wxWidgets (Impactor)