]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wrong caption for html window, cleanup
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3792 return wxPyTestDisplayAvailable();
3793 }
3794
3795 void wxApp_CleanUp() {
3796 __wxPyCleanup();
3797 }
3798
3799
3800 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3801
3802
3803
3804
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_FromCharPtr(const char *cptr)
3808 {
3809 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3810 }
3811
3812
3813 #if 0 // #ifdef __WXMAC__
3814
3815 // A dummy class that raises an exception if used...
3816 class wxEventLoop
3817 {
3818 public:
3819 wxEventLoop() { wxPyRaiseNotImplemented(); }
3820 int Run() { return 0; }
3821 void Exit(int rc = 0) {}
3822 bool Pending() const { return false; }
3823 bool Dispatch() { return false; }
3824 bool IsRunning() const { return false; }
3825 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3826 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3827 };
3828
3829 #else
3830
3831 #include <wx/evtloop.h>
3832
3833 #endif
3834
3835
3836
3837 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3838 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3839 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3840 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3841 wxWindowList& list = self->GetChildren();
3842 return wxPy_ConvertList(&list);
3843 }
3844 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3934 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3935 static const wxString wxPyControlNameStr(wxControlNameStr);
3936 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3937 if (clientData) {
3938 wxPyClientData* data = new wxPyClientData(clientData);
3939 return self->Append(item, data);
3940 } else
3941 return self->Append(item);
3942 }
3943 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3944 if (clientData) {
3945 wxPyClientData* data = new wxPyClientData(clientData);
3946 return self->Insert(item, pos, data);
3947 } else
3948 return self->Insert(item, pos);
3949 }
3950 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3951 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3952 if (data) {
3953 Py_INCREF(data->m_obj);
3954 return data->m_obj;
3955 } else {
3956 Py_INCREF(Py_None);
3957 return Py_None;
3958 }
3959 }
3960 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 self->SetClientObject(n, data);
3963 }
3964
3965
3966 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3967 wxPyUserData* data = NULL;
3968 if ( userData ) {
3969 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3970 data = new wxPyUserData(userData);
3971 wxPyEndBlockThreads(blocked);
3972 }
3973 return new wxSizerItem(window, proportion, flag, border, data);
3974 }
3975 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3976 wxPyUserData* data = NULL;
3977 if ( userData ) {
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 data = new wxPyUserData(userData);
3980 wxPyEndBlockThreads(blocked);
3981 }
3982 return new wxSizerItem(width, height, proportion, flag, border, data);
3983 }
3984 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3985 wxPyUserData* data = NULL;
3986 if ( userData ) {
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 data = new wxPyUserData(userData);
3989 wxPyEndBlockThreads(blocked);
3990 }
3991 return new wxSizerItem(sizer, proportion, flag, border, data);
3992 }
3993
3994 SWIGINTERNINLINE PyObject *
3995 SWIG_From_float (float value)
3996 {
3997 return SWIG_From_double (value);
3998 }
3999
4000 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4001 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4002 if (data) {
4003 Py_INCREF(data->m_obj);
4004 return data->m_obj;
4005 } else {
4006 Py_INCREF(Py_None);
4007 return Py_None;
4008 }
4009 }
4010 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4011 wxPyUserData* data = NULL;
4012 if ( userData ) {
4013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4014 data = new wxPyUserData(userData);
4015 wxPyEndBlockThreads(blocked);
4016 }
4017 self->SetUserData(data);
4018 }
4019
4020 // Figure out the type of the sizer item
4021
4022 struct wxPySizerItemInfo {
4023 wxPySizerItemInfo()
4024 : window(NULL), sizer(NULL), gotSize(false),
4025 size(wxDefaultSize), gotPos(false), pos(-1)
4026 {}
4027
4028 wxWindow* window;
4029 wxSizer* sizer;
4030 bool gotSize;
4031 wxSize size;
4032 bool gotPos;
4033 int pos;
4034 };
4035
4036 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4037
4038 wxPySizerItemInfo info;
4039 wxSize size;
4040 wxSize* sizePtr = &size;
4041
4042 // Find out what the type of the item is
4043 // try wxWindow
4044 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4045 PyErr_Clear();
4046 info.window = NULL;
4047
4048 // try wxSizer
4049 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4050 PyErr_Clear();
4051 info.sizer = NULL;
4052
4053 // try wxSize or (w,h)
4054 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4055 info.size = *sizePtr;
4056 info.gotSize = true;
4057 }
4058
4059 // or a single int
4060 if (checkIdx && PyInt_Check(item)) {
4061 info.pos = PyInt_AsLong(item);
4062 info.gotPos = true;
4063 }
4064 }
4065 }
4066
4067 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4068 // no expected type, figure out what kind of error message to generate
4069 if ( !checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4071 else if ( checkSize && !checkIdx )
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4073 else if ( !checkSize && checkIdx)
4074 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4075 else
4076 // can this one happen?
4077 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4078 }
4079
4080 return info;
4081 }
4082
4083 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4084 if (!self->GetClientObject())
4085 self->SetClientObject(new wxPyOORClientData(_self));
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Add method if a valid item type was found
4099 if ( info.window )
4100 return self->Add(info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Add(info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Insert method if a valid item type was found
4121 if ( info.window )
4122 return self->Insert(before, info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Insert(before, info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4132
4133 wxPyUserData* data = NULL;
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4136 if ( userData && (info.window || info.sizer || info.gotSize) )
4137 data = new wxPyUserData(userData);
4138 if ( info.sizer )
4139 PyObject_SetAttrString(item,"thisown",Py_False);
4140 wxPyEndBlockThreads(blocked);
4141
4142 // Now call the real Prepend method if a valid item type was found
4143 if ( info.window )
4144 return self->Prepend(info.window, proportion, flag, border, data);
4145 else if ( info.sizer )
4146 return self->Prepend(info.sizer, proportion, flag, border, data);
4147 else if (info.gotSize)
4148 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4149 proportion, flag, border, data);
4150 else
4151 return NULL;
4152 }
4153 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4156 wxPyEndBlockThreads(blocked);
4157 if ( info.window )
4158 return self->Remove(info.window);
4159 else if ( info.sizer )
4160 return self->Remove(info.sizer);
4161 else if ( info.gotPos )
4162 return self->Remove(info.pos);
4163 else
4164 return false;
4165 }
4166 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Detach(info.window);
4172 else if ( info.sizer )
4173 return self->Detach(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Detach(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->GetItem(info.window);
4185 else if ( info.sizer )
4186 return self->GetItem(info.sizer);
4187 else if ( info.gotPos )
4188 return self->GetItem(info.pos);
4189 else
4190 return NULL;
4191 }
4192 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 self->SetItemMinSize(info.window, size);
4198 else if ( info.sizer )
4199 self->SetItemMinSize(info.sizer, size);
4200 else if ( info.gotPos )
4201 self->SetItemMinSize(info.pos, size);
4202 }
4203 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4204 wxSizerItemList& list = self->GetChildren();
4205 return wxPy_ConvertList(&list);
4206 }
4207 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 return self->Show(info.window, show, recursive);
4213 else if ( info.sizer )
4214 return self->Show(info.sizer, show, recursive);
4215 else if ( info.gotPos )
4216 return self->Show(info.pos, show);
4217 else
4218 return false;
4219 }
4220 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->IsShown(info.window);
4226 else if ( info.sizer )
4227 return self->IsShown(info.sizer);
4228 else if ( info.gotPos )
4229 return self->IsShown(info.pos);
4230 else
4231 return false;
4232 }
4233
4234 // See pyclasses.h
4235 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4236 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4237 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4238
4239
4240
4241
4242 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4243 {
4244 if (source == Py_None) {
4245 **obj = wxGBPosition(-1,-1);
4246 return true;
4247 }
4248 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4249 }
4250
4251 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4252 {
4253 if (source == Py_None) {
4254 **obj = wxGBSpan(-1,-1);
4255 return true;
4256 }
4257 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4258 }
4259
4260
4261 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4262 wxGBPosition temp, *obj = &temp;
4263 if ( other == Py_None ) return false;
4264 if ( ! wxGBPosition_helper(other, &obj) ) {
4265 PyErr_Clear();
4266 return false;
4267 }
4268 return self->operator==(*obj);
4269 }
4270 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4271 wxGBPosition temp, *obj = &temp;
4272 if ( other == Py_None ) return true;
4273 if ( ! wxGBPosition_helper(other, &obj)) {
4274 PyErr_Clear();
4275 return true;
4276 }
4277 return self->operator!=(*obj);
4278 }
4279 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4280 self->SetRow(row);
4281 self->SetCol(col);
4282 }
4283 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4285 PyObject* tup = PyTuple_New(2);
4286 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4287 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4288 wxPyEndBlockThreads(blocked);
4289 return tup;
4290 }
4291 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4292 wxGBSpan temp, *obj = &temp;
4293 if ( other == Py_None ) return false;
4294 if ( ! wxGBSpan_helper(other, &obj) ) {
4295 PyErr_Clear();
4296 return false;
4297 }
4298 return self->operator==(*obj);
4299 }
4300 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4301 wxGBSpan temp, *obj = &temp;
4302 if ( other == Py_None ) return true;
4303 if ( ! wxGBSpan_helper(other, &obj)) {
4304 PyErr_Clear();
4305 return true;
4306 }
4307 return self->operator!=(*obj);
4308 }
4309 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4310 self->SetRowspan(rowspan);
4311 self->SetColspan(colspan);
4312 }
4313 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4315 PyObject* tup = PyTuple_New(2);
4316 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4317 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4318 wxPyEndBlockThreads(blocked);
4319 return tup;
4320 }
4321 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,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(window, pos, span, flag, border, data);
4329 }
4330 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4331 wxPyUserData* data = NULL;
4332 if ( userData ) {
4333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4334 data = new wxPyUserData(userData);
4335 wxPyEndBlockThreads(blocked);
4336 }
4337 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4338 }
4339 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4340 wxPyUserData* data = NULL;
4341 if ( userData ) {
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 data = new wxPyUserData(userData);
4344 wxPyEndBlockThreads(blocked);
4345 }
4346 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4347 }
4348 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4349 int row, col;
4350 self->GetEndPos(row, col);
4351 return wxGBPosition(row, col);
4352 }
4353 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4354
4355 wxPyUserData* data = NULL;
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4358 if ( userData && (info.window || info.sizer || info.gotSize) )
4359 data = new wxPyUserData(userData);
4360 if ( info.sizer )
4361 PyObject_SetAttrString(item,"thisown",Py_False);
4362 wxPyEndBlockThreads(blocked);
4363
4364 // Now call the real Add method if a valid item type was found
4365 if ( info.window )
4366 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4367 else if ( info.sizer )
4368 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4369 else if (info.gotSize)
4370 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4371 pos, span, flag, border, data);
4372 return NULL;
4373 }
4374
4375
4376 #ifdef __cplusplus
4377 extern "C" {
4378 #endif
4379 SWIGINTERN int EmptyString_set(PyObject *) {
4380 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4381 return 1;
4382 }
4383
4384
4385 SWIGINTERN PyObject *EmptyString_get(void) {
4386 PyObject *pyobj = 0;
4387
4388 {
4389 #if wxUSE_UNICODE
4390 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #else
4392 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4393 #endif
4394 }
4395 return pyobj;
4396 }
4397
4398
4399 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400 PyObject *resultobj = 0;
4401 wxObject *arg1 = (wxObject *) 0 ;
4402 wxString result;
4403 void *argp1 = 0 ;
4404 int res1 = 0 ;
4405 PyObject *swig_obj[1] ;
4406
4407 if (!args) SWIG_fail;
4408 swig_obj[0] = args;
4409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4410 if (!SWIG_IsOK(res1)) {
4411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4412 }
4413 arg1 = reinterpret_cast< wxObject * >(argp1);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxObject_GetClassName(arg1);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 {
4421 #if wxUSE_UNICODE
4422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4423 #else
4424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4425 #endif
4426 }
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434 PyObject *resultobj = 0;
4435 wxObject *arg1 = (wxObject *) 0 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 PyObject *swig_obj[1] ;
4439
4440 if (!args) SWIG_fail;
4441 swig_obj[0] = args;
4442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4443 if (!SWIG_IsOK(res1)) {
4444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4445 }
4446 arg1 = reinterpret_cast< wxObject * >(argp1);
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 wxObject_Destroy(arg1);
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 resultobj = SWIG_Py_Void();
4454 return resultobj;
4455 fail:
4456 return NULL;
4457 }
4458
4459
4460 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *obj;
4462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4463 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4464 return SWIG_Py_Void();
4465 }
4466
4467 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4468 PyObject *resultobj = 0;
4469 wxSize *arg1 = (wxSize *) 0 ;
4470 int arg2 ;
4471 void *argp1 = 0 ;
4472 int res1 = 0 ;
4473 int val2 ;
4474 int ecode2 = 0 ;
4475 PyObject *swig_obj[2] ;
4476
4477 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4479 if (!SWIG_IsOK(res1)) {
4480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4481 }
4482 arg1 = reinterpret_cast< wxSize * >(argp1);
4483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4484 if (!SWIG_IsOK(ecode2)) {
4485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4486 }
4487 arg2 = static_cast< int >(val2);
4488 if (arg1) (arg1)->x = arg2;
4489
4490 resultobj = SWIG_Py_Void();
4491 return resultobj;
4492 fail:
4493 return NULL;
4494 }
4495
4496
4497 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498 PyObject *resultobj = 0;
4499 wxSize *arg1 = (wxSize *) 0 ;
4500 int result;
4501 void *argp1 = 0 ;
4502 int res1 = 0 ;
4503 PyObject *swig_obj[1] ;
4504
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4510 }
4511 arg1 = reinterpret_cast< wxSize * >(argp1);
4512 result = (int) ((arg1)->x);
4513 resultobj = SWIG_From_int(static_cast< int >(result));
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521 PyObject *resultobj = 0;
4522 wxSize *arg1 = (wxSize *) 0 ;
4523 int arg2 ;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 int val2 ;
4527 int ecode2 = 0 ;
4528 PyObject *swig_obj[2] ;
4529
4530 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4532 if (!SWIG_IsOK(res1)) {
4533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4534 }
4535 arg1 = reinterpret_cast< wxSize * >(argp1);
4536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4537 if (!SWIG_IsOK(ecode2)) {
4538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4539 }
4540 arg2 = static_cast< int >(val2);
4541 if (arg1) (arg1)->y = arg2;
4542
4543 resultobj = SWIG_Py_Void();
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551 PyObject *resultobj = 0;
4552 wxSize *arg1 = (wxSize *) 0 ;
4553 int result;
4554 void *argp1 = 0 ;
4555 int res1 = 0 ;
4556 PyObject *swig_obj[1] ;
4557
4558 if (!args) SWIG_fail;
4559 swig_obj[0] = args;
4560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4561 if (!SWIG_IsOK(res1)) {
4562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4563 }
4564 arg1 = reinterpret_cast< wxSize * >(argp1);
4565 result = (int) ((arg1)->y);
4566 resultobj = SWIG_From_int(static_cast< int >(result));
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj = 0;
4575 int arg1 = (int) 0 ;
4576 int arg2 = (int) 0 ;
4577 wxSize *result = 0 ;
4578 int val1 ;
4579 int ecode1 = 0 ;
4580 int val2 ;
4581 int ecode2 = 0 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char * kwnames[] = {
4585 (char *) "w",(char *) "h", NULL
4586 };
4587
4588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4589 if (obj0) {
4590 ecode1 = SWIG_AsVal_int(obj0, &val1);
4591 if (!SWIG_IsOK(ecode1)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4593 }
4594 arg1 = static_cast< int >(val1);
4595 }
4596 if (obj1) {
4597 ecode2 = SWIG_AsVal_int(obj1, &val2);
4598 if (!SWIG_IsOK(ecode2)) {
4599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4600 }
4601 arg2 = static_cast< int >(val2);
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (wxSize *)new wxSize(arg1,arg2);
4606 wxPyEndAllowThreads(__tstate);
4607 if (PyErr_Occurred()) SWIG_fail;
4608 }
4609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *resultobj = 0;
4618 wxSize *arg1 = (wxSize *) 0 ;
4619 void *argp1 = 0 ;
4620 int res1 = 0 ;
4621 PyObject *swig_obj[1] ;
4622
4623 if (!args) SWIG_fail;
4624 swig_obj[0] = args;
4625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4626 if (!SWIG_IsOK(res1)) {
4627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4628 }
4629 arg1 = reinterpret_cast< wxSize * >(argp1);
4630 {
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 delete arg1;
4633
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 resultobj = SWIG_Py_Void();
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = 0;
4646 wxSize *arg1 = (wxSize *) 0 ;
4647 PyObject *arg2 = (PyObject *) 0 ;
4648 bool result;
4649 void *argp1 = 0 ;
4650 int res1 = 0 ;
4651 PyObject * obj0 = 0 ;
4652 PyObject * obj1 = 0 ;
4653 char * kwnames[] = {
4654 (char *) "self",(char *) "other", NULL
4655 };
4656
4657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4661 }
4662 arg1 = reinterpret_cast< wxSize * >(argp1);
4663 arg2 = obj1;
4664 {
4665 result = (bool)wxSize___eq__(arg1,arg2);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 {
4669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4670 }
4671 return resultobj;
4672 fail:
4673 return NULL;
4674 }
4675
4676
4677 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4678 PyObject *resultobj = 0;
4679 wxSize *arg1 = (wxSize *) 0 ;
4680 PyObject *arg2 = (PyObject *) 0 ;
4681 bool result;
4682 void *argp1 = 0 ;
4683 int res1 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "self",(char *) "other", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 arg2 = obj1;
4697 {
4698 result = (bool)wxSize___ne__(arg1,arg2);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 {
4702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4703 }
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj = 0;
4712 wxSize *arg1 = (wxSize *) 0 ;
4713 wxSize *arg2 = 0 ;
4714 wxSize result;
4715 void *argp1 = 0 ;
4716 int res1 = 0 ;
4717 wxSize temp2 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "self",(char *) "sz", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 arg2 = &temp2;
4732 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4733 }
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (arg1)->operator +((wxSize const &)*arg2);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 wxSize *arg1 = (wxSize *) 0 ;
4750 wxSize *arg2 = 0 ;
4751 wxSize result;
4752 void *argp1 = 0 ;
4753 int res1 = 0 ;
4754 wxSize temp2 ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "self",(char *) "sz", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4765 }
4766 arg1 = reinterpret_cast< wxSize * >(argp1);
4767 {
4768 arg2 = &temp2;
4769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 result = (arg1)->operator -((wxSize const &)*arg2);
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj = 0;
4786 wxSize *arg1 = (wxSize *) 0 ;
4787 wxSize *arg2 = 0 ;
4788 void *argp1 = 0 ;
4789 int res1 = 0 ;
4790 wxSize temp2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char * kwnames[] = {
4794 (char *) "self",(char *) "sz", NULL
4795 };
4796
4797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4801 }
4802 arg1 = reinterpret_cast< wxSize * >(argp1);
4803 {
4804 arg2 = &temp2;
4805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 (arg1)->IncTo((wxSize const &)*arg2);
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 resultobj = SWIG_Py_Void();
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj = 0;
4822 wxSize *arg1 = (wxSize *) 0 ;
4823 wxSize *arg2 = 0 ;
4824 void *argp1 = 0 ;
4825 int res1 = 0 ;
4826 wxSize temp2 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4829 char * kwnames[] = {
4830 (char *) "self",(char *) "sz", NULL
4831 };
4832
4833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4835 if (!SWIG_IsOK(res1)) {
4836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4837 }
4838 arg1 = reinterpret_cast< wxSize * >(argp1);
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 (arg1)->DecTo((wxSize const &)*arg2);
4846 wxPyEndAllowThreads(__tstate);
4847 if (PyErr_Occurred()) SWIG_fail;
4848 }
4849 resultobj = SWIG_Py_Void();
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 wxSize *arg1 = (wxSize *) 0 ;
4859 int arg2 ;
4860 int arg3 ;
4861 void *argp1 = 0 ;
4862 int res1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 int val3 ;
4866 int ecode3 = 0 ;
4867 PyObject * obj0 = 0 ;
4868 PyObject * obj1 = 0 ;
4869 PyObject * obj2 = 0 ;
4870 char * kwnames[] = {
4871 (char *) "self",(char *) "dx",(char *) "dy", NULL
4872 };
4873
4874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4876 if (!SWIG_IsOK(res1)) {
4877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4878 }
4879 arg1 = reinterpret_cast< wxSize * >(argp1);
4880 ecode2 = SWIG_AsVal_int(obj1, &val2);
4881 if (!SWIG_IsOK(ecode2)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4883 }
4884 arg2 = static_cast< int >(val2);
4885 ecode3 = SWIG_AsVal_int(obj2, &val3);
4886 if (!SWIG_IsOK(ecode3)) {
4887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4888 }
4889 arg3 = static_cast< int >(val3);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 (arg1)->IncBy(arg2,arg3);
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_Py_Void();
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 int arg2 ;
4907 int arg3 ;
4908 void *argp1 = 0 ;
4909 int res1 = 0 ;
4910 int val2 ;
4911 int ecode2 = 0 ;
4912 int val3 ;
4913 int ecode3 = 0 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 PyObject * obj2 = 0 ;
4917 char * kwnames[] = {
4918 (char *) "self",(char *) "dx",(char *) "dy", NULL
4919 };
4920
4921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4923 if (!SWIG_IsOK(res1)) {
4924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4925 }
4926 arg1 = reinterpret_cast< wxSize * >(argp1);
4927 ecode2 = SWIG_AsVal_int(obj1, &val2);
4928 if (!SWIG_IsOK(ecode2)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4930 }
4931 arg2 = static_cast< int >(val2);
4932 ecode3 = SWIG_AsVal_int(obj2, &val3);
4933 if (!SWIG_IsOK(ecode3)) {
4934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4935 }
4936 arg3 = static_cast< int >(val3);
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 (arg1)->DecBy(arg2,arg3);
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_Py_Void();
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj = 0;
4952 wxSize *arg1 = (wxSize *) 0 ;
4953 float arg2 ;
4954 float arg3 ;
4955 void *argp1 = 0 ;
4956 int res1 = 0 ;
4957 float val2 ;
4958 int ecode2 = 0 ;
4959 float val3 ;
4960 int ecode3 = 0 ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4972 }
4973 arg1 = reinterpret_cast< wxSize * >(argp1);
4974 ecode2 = SWIG_AsVal_float(obj1, &val2);
4975 if (!SWIG_IsOK(ecode2)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4977 }
4978 arg2 = static_cast< float >(val2);
4979 ecode3 = SWIG_AsVal_float(obj2, &val3);
4980 if (!SWIG_IsOK(ecode3)) {
4981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4982 }
4983 arg3 = static_cast< float >(val3);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 (arg1)->Scale(arg2,arg3);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = SWIG_Py_Void();
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj = 0;
4999 wxSize *arg1 = (wxSize *) 0 ;
5000 int arg2 ;
5001 int arg3 ;
5002 void *argp1 = 0 ;
5003 int res1 = 0 ;
5004 int val2 ;
5005 int ecode2 = 0 ;
5006 int val3 ;
5007 int ecode3 = 0 ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "w",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 ecode3 = SWIG_AsVal_int(obj2, &val3);
5027 if (!SWIG_IsOK(ecode3)) {
5028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5029 }
5030 arg3 = static_cast< int >(val3);
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 (arg1)->Set(arg2,arg3);
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 resultobj = SWIG_Py_Void();
5038 return resultobj;
5039 fail:
5040 return NULL;
5041 }
5042
5043
5044 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5045 PyObject *resultobj = 0;
5046 wxSize *arg1 = (wxSize *) 0 ;
5047 int arg2 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 int val2 ;
5051 int ecode2 = 0 ;
5052 PyObject * obj0 = 0 ;
5053 PyObject * obj1 = 0 ;
5054 char * kwnames[] = {
5055 (char *) "self",(char *) "w", NULL
5056 };
5057
5058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 ecode2 = SWIG_AsVal_int(obj1, &val2);
5065 if (!SWIG_IsOK(ecode2)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5067 }
5068 arg2 = static_cast< int >(val2);
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 (arg1)->SetWidth(arg2);
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 resultobj = SWIG_Py_Void();
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj = 0;
5084 wxSize *arg1 = (wxSize *) 0 ;
5085 int arg2 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 PyObject * obj0 = 0 ;
5091 PyObject * obj1 = 0 ;
5092 char * kwnames[] = {
5093 (char *) "self",(char *) "h", NULL
5094 };
5095
5096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5098 if (!SWIG_IsOK(res1)) {
5099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5100 }
5101 arg1 = reinterpret_cast< wxSize * >(argp1);
5102 ecode2 = SWIG_AsVal_int(obj1, &val2);
5103 if (!SWIG_IsOK(ecode2)) {
5104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5105 }
5106 arg2 = static_cast< int >(val2);
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 (arg1)->SetHeight(arg2);
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 resultobj = SWIG_Py_Void();
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxSize *arg1 = (wxSize *) 0 ;
5123 int result;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 PyObject *swig_obj[1] ;
5127
5128 if (!args) SWIG_fail;
5129 swig_obj[0] = args;
5130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5131 if (!SWIG_IsOK(res1)) {
5132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5133 }
5134 arg1 = reinterpret_cast< wxSize * >(argp1);
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (int)((wxSize const *)arg1)->GetWidth();
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 resultobj = SWIG_From_int(static_cast< int >(result));
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxSize *arg1 = (wxSize *) 0 ;
5151 int result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5161 }
5162 arg1 = reinterpret_cast< wxSize * >(argp1);
5163 {
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 result = (int)((wxSize const *)arg1)->GetHeight();
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_From_int(static_cast< int >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxSize *arg1 = (wxSize *) 0 ;
5179 bool result;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 PyObject *swig_obj[1] ;
5183
5184 if (!args) SWIG_fail;
5185 swig_obj[0] = args;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5189 }
5190 arg1 = reinterpret_cast< wxSize * >(argp1);
5191 {
5192 PyThreadState* __tstate = wxPyBeginAllowThreads();
5193 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5194 wxPyEndAllowThreads(__tstate);
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 {
5198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5199 }
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj = 0;
5208 wxSize *arg1 = (wxSize *) 0 ;
5209 wxSize *arg2 = 0 ;
5210 void *argp1 = 0 ;
5211 int res1 = 0 ;
5212 wxSize temp2 ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 char * kwnames[] = {
5216 (char *) "self",(char *) "size", NULL
5217 };
5218
5219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5221 if (!SWIG_IsOK(res1)) {
5222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5223 }
5224 arg1 = reinterpret_cast< wxSize * >(argp1);
5225 {
5226 arg2 = &temp2;
5227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5228 }
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 (arg1)->SetDefaults((wxSize const &)*arg2);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5243 PyObject *resultobj = 0;
5244 wxSize *arg1 = (wxSize *) 0 ;
5245 PyObject *result = 0 ;
5246 void *argp1 = 0 ;
5247 int res1 = 0 ;
5248 PyObject *swig_obj[1] ;
5249
5250 if (!args) SWIG_fail;
5251 swig_obj[0] = args;
5252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5253 if (!SWIG_IsOK(res1)) {
5254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5255 }
5256 arg1 = reinterpret_cast< wxSize * >(argp1);
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = (PyObject *)wxSize_Get(arg1);
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 resultobj = result;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271 PyObject *obj;
5272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5273 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5274 return SWIG_Py_Void();
5275 }
5276
5277 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5278 return SWIG_Python_InitShadowInstance(args);
5279 }
5280
5281 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 PyObject *resultobj = 0;
5283 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5284 double arg2 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 double val2 ;
5288 int ecode2 = 0 ;
5289 PyObject *swig_obj[2] ;
5290
5291 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5295 }
5296 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5297 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5298 if (!SWIG_IsOK(ecode2)) {
5299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5300 }
5301 arg2 = static_cast< double >(val2);
5302 if (arg1) (arg1)->x = arg2;
5303
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5314 double result;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5324 }
5325 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5326 result = (double) ((arg1)->x);
5327 resultobj = SWIG_From_double(static_cast< double >(result));
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 double arg2 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 double val2 ;
5341 int ecode2 = 0 ;
5342 PyObject *swig_obj[2] ;
5343
5344 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5346 if (!SWIG_IsOK(res1)) {
5347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5348 }
5349 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5350 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5351 if (!SWIG_IsOK(ecode2)) {
5352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5353 }
5354 arg2 = static_cast< double >(val2);
5355 if (arg1) (arg1)->y = arg2;
5356
5357 resultobj = SWIG_Py_Void();
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5367 double result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject *swig_obj[1] ;
5371
5372 if (!args) SWIG_fail;
5373 swig_obj[0] = args;
5374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5375 if (!SWIG_IsOK(res1)) {
5376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5377 }
5378 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5379 result = (double) ((arg1)->y);
5380 resultobj = SWIG_From_double(static_cast< double >(result));
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5388 PyObject *resultobj = 0;
5389 double arg1 = (double) 0.0 ;
5390 double arg2 = (double) 0.0 ;
5391 wxRealPoint *result = 0 ;
5392 double val1 ;
5393 int ecode1 = 0 ;
5394 double val2 ;
5395 int ecode2 = 0 ;
5396 PyObject * obj0 = 0 ;
5397 PyObject * obj1 = 0 ;
5398 char * kwnames[] = {
5399 (char *) "x",(char *) "y", NULL
5400 };
5401
5402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5403 if (obj0) {
5404 ecode1 = SWIG_AsVal_double(obj0, &val1);
5405 if (!SWIG_IsOK(ecode1)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5407 }
5408 arg1 = static_cast< double >(val1);
5409 }
5410 if (obj1) {
5411 ecode2 = SWIG_AsVal_double(obj1, &val2);
5412 if (!SWIG_IsOK(ecode2)) {
5413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5414 }
5415 arg2 = static_cast< double >(val2);
5416 }
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 PyObject *resultobj = 0;
5432 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 PyObject *swig_obj[1] ;
5436
5437 if (!args) SWIG_fail;
5438 swig_obj[0] = args;
5439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 delete arg1;
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 resultobj = SWIG_Py_Void();
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj = 0;
5460 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5461 PyObject *arg2 = (PyObject *) 0 ;
5462 bool result;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 PyObject * obj0 = 0 ;
5466 PyObject * obj1 = 0 ;
5467 char * kwnames[] = {
5468 (char *) "self",(char *) "other", NULL
5469 };
5470
5471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5473 if (!SWIG_IsOK(res1)) {
5474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5475 }
5476 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5477 arg2 = obj1;
5478 {
5479 result = (bool)wxRealPoint___eq__(arg1,arg2);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5484 }
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj = 0;
5493 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5494 PyObject *arg2 = (PyObject *) 0 ;
5495 bool result;
5496 void *argp1 = 0 ;
5497 int res1 = 0 ;
5498 PyObject * obj0 = 0 ;
5499 PyObject * obj1 = 0 ;
5500 char * kwnames[] = {
5501 (char *) "self",(char *) "other", NULL
5502 };
5503
5504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 arg2 = obj1;
5511 {
5512 result = (bool)wxRealPoint___ne__(arg1,arg2);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5527 wxRealPoint *arg2 = 0 ;
5528 wxRealPoint result;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 wxRealPoint temp2 ;
5532 PyObject * obj0 = 0 ;
5533 PyObject * obj1 = 0 ;
5534 char * kwnames[] = {
5535 (char *) "self",(char *) "pt", NULL
5536 };
5537
5538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 {
5545 arg2 = &temp2;
5546 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj = 0;
5563 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5564 wxRealPoint *arg2 = 0 ;
5565 wxRealPoint result;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 wxRealPoint temp2 ;
5569 PyObject * obj0 = 0 ;
5570 PyObject * obj1 = 0 ;
5571 char * kwnames[] = {
5572 (char *) "self",(char *) "pt", NULL
5573 };
5574
5575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5581 {
5582 arg2 = &temp2;
5583 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5601 double arg2 ;
5602 double arg3 ;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 double val2 ;
5606 int ecode2 = 0 ;
5607 double val3 ;
5608 int ecode3 = 0 ;
5609 PyObject * obj0 = 0 ;
5610 PyObject * obj1 = 0 ;
5611 PyObject * obj2 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "self",(char *) "x",(char *) "y", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5620 }
5621 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5622 ecode2 = SWIG_AsVal_double(obj1, &val2);
5623 if (!SWIG_IsOK(ecode2)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5625 }
5626 arg2 = static_cast< double >(val2);
5627 ecode3 = SWIG_AsVal_double(obj2, &val3);
5628 if (!SWIG_IsOK(ecode3)) {
5629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5630 }
5631 arg3 = static_cast< double >(val3);
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 wxRealPoint_Set(arg1,arg2,arg3);
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 resultobj = SWIG_Py_Void();
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5646 PyObject *resultobj = 0;
5647 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5648 PyObject *result = 0 ;
5649 void *argp1 = 0 ;
5650 int res1 = 0 ;
5651 PyObject *swig_obj[1] ;
5652
5653 if (!args) SWIG_fail;
5654 swig_obj[0] = args;
5655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5656 if (!SWIG_IsOK(res1)) {
5657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5658 }
5659 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5660 {
5661 PyThreadState* __tstate = wxPyBeginAllowThreads();
5662 result = (PyObject *)wxRealPoint_Get(arg1);
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 resultobj = result;
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5674 PyObject *obj;
5675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5676 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5677 return SWIG_Py_Void();
5678 }
5679
5680 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681 return SWIG_Python_InitShadowInstance(args);
5682 }
5683
5684 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 PyObject *resultobj = 0;
5686 wxPoint *arg1 = (wxPoint *) 0 ;
5687 int arg2 ;
5688 void *argp1 = 0 ;
5689 int res1 = 0 ;
5690 int val2 ;
5691 int ecode2 = 0 ;
5692 PyObject *swig_obj[2] ;
5693
5694 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5696 if (!SWIG_IsOK(res1)) {
5697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5698 }
5699 arg1 = reinterpret_cast< wxPoint * >(argp1);
5700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5701 if (!SWIG_IsOK(ecode2)) {
5702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5703 }
5704 arg2 = static_cast< int >(val2);
5705 if (arg1) (arg1)->x = arg2;
5706
5707 resultobj = SWIG_Py_Void();
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 PyObject *resultobj = 0;
5716 wxPoint *arg1 = (wxPoint *) 0 ;
5717 int result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 PyObject *swig_obj[1] ;
5721
5722 if (!args) SWIG_fail;
5723 swig_obj[0] = args;
5724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5725 if (!SWIG_IsOK(res1)) {
5726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5727 }
5728 arg1 = reinterpret_cast< wxPoint * >(argp1);
5729 result = (int) ((arg1)->x);
5730 resultobj = SWIG_From_int(static_cast< int >(result));
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 int arg2 ;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 int val2 ;
5744 int ecode2 = 0 ;
5745 PyObject *swig_obj[2] ;
5746
5747 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5749 if (!SWIG_IsOK(res1)) {
5750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5751 }
5752 arg1 = reinterpret_cast< wxPoint * >(argp1);
5753 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5754 if (!SWIG_IsOK(ecode2)) {
5755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5756 }
5757 arg2 = static_cast< int >(val2);
5758 if (arg1) (arg1)->y = arg2;
5759
5760 resultobj = SWIG_Py_Void();
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5768 PyObject *resultobj = 0;
5769 wxPoint *arg1 = (wxPoint *) 0 ;
5770 int result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject *swig_obj[1] ;
5774
5775 if (!args) SWIG_fail;
5776 swig_obj[0] = args;
5777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5778 if (!SWIG_IsOK(res1)) {
5779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5780 }
5781 arg1 = reinterpret_cast< wxPoint * >(argp1);
5782 result = (int) ((arg1)->y);
5783 resultobj = SWIG_From_int(static_cast< int >(result));
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 int arg1 = (int) 0 ;
5793 int arg2 = (int) 0 ;
5794 wxPoint *result = 0 ;
5795 int val1 ;
5796 int ecode1 = 0 ;
5797 int val2 ;
5798 int ecode2 = 0 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "x",(char *) "y", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5806 if (obj0) {
5807 ecode1 = SWIG_AsVal_int(obj0, &val1);
5808 if (!SWIG_IsOK(ecode1)) {
5809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5810 }
5811 arg1 = static_cast< int >(val1);
5812 }
5813 if (obj1) {
5814 ecode2 = SWIG_AsVal_int(obj1, &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5817 }
5818 arg2 = static_cast< int >(val2);
5819 }
5820 {
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 result = (wxPoint *)new wxPoint(arg1,arg2);
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5834 PyObject *resultobj = 0;
5835 wxPoint *arg1 = (wxPoint *) 0 ;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 PyObject *swig_obj[1] ;
5839
5840 if (!args) SWIG_fail;
5841 swig_obj[0] = args;
5842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 delete arg1;
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 resultobj = SWIG_Py_Void();
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj = 0;
5863 wxPoint *arg1 = (wxPoint *) 0 ;
5864 PyObject *arg2 = (PyObject *) 0 ;
5865 bool result;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 PyObject * obj0 = 0 ;
5869 PyObject * obj1 = 0 ;
5870 char * kwnames[] = {
5871 (char *) "self",(char *) "other", NULL
5872 };
5873
5874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5876 if (!SWIG_IsOK(res1)) {
5877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5878 }
5879 arg1 = reinterpret_cast< wxPoint * >(argp1);
5880 arg2 = obj1;
5881 {
5882 result = (bool)wxPoint___eq__(arg1,arg2);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj = 0;
5896 wxPoint *arg1 = (wxPoint *) 0 ;
5897 PyObject *arg2 = (PyObject *) 0 ;
5898 bool result;
5899 void *argp1 = 0 ;
5900 int res1 = 0 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "other", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5911 }
5912 arg1 = reinterpret_cast< wxPoint * >(argp1);
5913 arg2 = obj1;
5914 {
5915 result = (bool)wxPoint___ne__(arg1,arg2);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 {
5919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = 0;
5929 wxPoint *arg1 = (wxPoint *) 0 ;
5930 wxPoint *arg2 = 0 ;
5931 wxPoint result;
5932 void *argp1 = 0 ;
5933 int res1 = 0 ;
5934 wxPoint temp2 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "self",(char *) "pt", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5945 }
5946 arg1 = reinterpret_cast< wxPoint * >(argp1);
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = (arg1)->operator +((wxPoint const &)*arg2);
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxPoint *arg1 = (wxPoint *) 0 ;
5967 wxPoint *arg2 = 0 ;
5968 wxPoint result;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 wxPoint temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char * kwnames[] = {
5975 (char *) "self",(char *) "pt", NULL
5976 };
5977
5978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (arg1)->operator -((wxPoint const &)*arg2);
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 wxPoint *arg2 = 0 ;
6005 wxPoint *result = 0 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 wxPoint temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char * kwnames[] = {
6012 (char *) "self",(char *) "pt", NULL
6013 };
6014
6015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6017 if (!SWIG_IsOK(res1)) {
6018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6019 }
6020 arg1 = reinterpret_cast< wxPoint * >(argp1);
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 {
6028 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6029 result = (wxPoint *) &_result_ref;
6030 }
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj = 0;
6043 wxPoint *arg1 = (wxPoint *) 0 ;
6044 wxPoint *arg2 = 0 ;
6045 wxPoint *result = 0 ;
6046 void *argp1 = 0 ;
6047 int res1 = 0 ;
6048 wxPoint temp2 ;
6049 PyObject * obj0 = 0 ;
6050 PyObject * obj1 = 0 ;
6051 char * kwnames[] = {
6052 (char *) "self",(char *) "pt", NULL
6053 };
6054
6055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6057 if (!SWIG_IsOK(res1)) {
6058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6059 }
6060 arg1 = reinterpret_cast< wxPoint * >(argp1);
6061 {
6062 arg2 = &temp2;
6063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6064 }
6065 {
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 {
6068 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6069 result = (wxPoint *) &_result_ref;
6070 }
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = 0;
6083 wxPoint *arg1 = (wxPoint *) 0 ;
6084 long arg2 ;
6085 long arg3 ;
6086 void *argp1 = 0 ;
6087 int res1 = 0 ;
6088 long val2 ;
6089 int ecode2 = 0 ;
6090 long val3 ;
6091 int ecode3 = 0 ;
6092 PyObject * obj0 = 0 ;
6093 PyObject * obj1 = 0 ;
6094 PyObject * obj2 = 0 ;
6095 char * kwnames[] = {
6096 (char *) "self",(char *) "x",(char *) "y", NULL
6097 };
6098
6099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6101 if (!SWIG_IsOK(res1)) {
6102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6103 }
6104 arg1 = reinterpret_cast< wxPoint * >(argp1);
6105 ecode2 = SWIG_AsVal_long(obj1, &val2);
6106 if (!SWIG_IsOK(ecode2)) {
6107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6108 }
6109 arg2 = static_cast< long >(val2);
6110 ecode3 = SWIG_AsVal_long(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6113 }
6114 arg3 = static_cast< long >(val3);
6115 {
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 wxPoint_Set(arg1,arg2,arg3);
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 resultobj = SWIG_Py_Void();
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6129 PyObject *resultobj = 0;
6130 wxPoint *arg1 = (wxPoint *) 0 ;
6131 PyObject *result = 0 ;
6132 void *argp1 = 0 ;
6133 int res1 = 0 ;
6134 PyObject *swig_obj[1] ;
6135
6136 if (!args) SWIG_fail;
6137 swig_obj[0] = args;
6138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6139 if (!SWIG_IsOK(res1)) {
6140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6141 }
6142 arg1 = reinterpret_cast< wxPoint * >(argp1);
6143 {
6144 PyThreadState* __tstate = wxPyBeginAllowThreads();
6145 result = (PyObject *)wxPoint_Get(arg1);
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = result;
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6157 PyObject *obj;
6158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6160 return SWIG_Py_Void();
6161 }
6162
6163 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6164 return SWIG_Python_InitShadowInstance(args);
6165 }
6166
6167 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 int arg1 = (int) 0 ;
6170 int arg2 = (int) 0 ;
6171 int arg3 = (int) 0 ;
6172 int arg4 = (int) 0 ;
6173 wxRect *result = 0 ;
6174 int val1 ;
6175 int ecode1 = 0 ;
6176 int val2 ;
6177 int ecode2 = 0 ;
6178 int val3 ;
6179 int ecode3 = 0 ;
6180 int val4 ;
6181 int ecode4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 if (obj0) {
6192 ecode1 = SWIG_AsVal_int(obj0, &val1);
6193 if (!SWIG_IsOK(ecode1)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6195 }
6196 arg1 = static_cast< int >(val1);
6197 }
6198 if (obj1) {
6199 ecode2 = SWIG_AsVal_int(obj1, &val2);
6200 if (!SWIG_IsOK(ecode2)) {
6201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6202 }
6203 arg2 = static_cast< int >(val2);
6204 }
6205 if (obj2) {
6206 ecode3 = SWIG_AsVal_int(obj2, &val3);
6207 if (!SWIG_IsOK(ecode3)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6209 }
6210 arg3 = static_cast< int >(val3);
6211 }
6212 if (obj3) {
6213 ecode4 = SWIG_AsVal_int(obj3, &val4);
6214 if (!SWIG_IsOK(ecode4)) {
6215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6216 }
6217 arg4 = static_cast< int >(val4);
6218 }
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxPoint *arg1 = 0 ;
6235 wxPoint *arg2 = 0 ;
6236 wxRect *result = 0 ;
6237 wxPoint temp1 ;
6238 wxPoint temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char * kwnames[] = {
6242 (char *) "topLeft",(char *) "bottomRight", NULL
6243 };
6244
6245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6246 {
6247 arg1 = &temp1;
6248 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6249 }
6250 {
6251 arg2 = &temp2;
6252 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6253 }
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxPoint *arg1 = 0 ;
6270 wxSize *arg2 = 0 ;
6271 wxRect *result = 0 ;
6272 wxPoint temp1 ;
6273 wxSize temp2 ;
6274 PyObject * obj0 = 0 ;
6275 PyObject * obj1 = 0 ;
6276 char * kwnames[] = {
6277 (char *) "pos",(char *) "size", NULL
6278 };
6279
6280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6281 {
6282 arg1 = &temp1;
6283 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6284 }
6285 {
6286 arg2 = &temp2;
6287 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6288 }
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxSize *arg1 = 0 ;
6305 wxRect *result = 0 ;
6306 wxSize temp1 ;
6307 PyObject * obj0 = 0 ;
6308 char * kwnames[] = {
6309 (char *) "size", NULL
6310 };
6311
6312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6313 {
6314 arg1 = &temp1;
6315 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6316 }
6317 {
6318 PyThreadState* __tstate = wxPyBeginAllowThreads();
6319 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6320 wxPyEndAllowThreads(__tstate);
6321 if (PyErr_Occurred()) SWIG_fail;
6322 }
6323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6324 return resultobj;
6325 fail:
6326 return NULL;
6327 }
6328
6329
6330 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6331 PyObject *resultobj = 0;
6332 wxRect *arg1 = (wxRect *) 0 ;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 delete arg1;
6347
6348 wxPyEndAllowThreads(__tstate);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 resultobj = SWIG_Py_Void();
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6359 PyObject *resultobj = 0;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 int result;
6362 void *argp1 = 0 ;
6363 int res1 = 0 ;
6364 PyObject *swig_obj[1] ;
6365
6366 if (!args) SWIG_fail;
6367 swig_obj[0] = args;
6368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6369 if (!SWIG_IsOK(res1)) {
6370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6371 }
6372 arg1 = reinterpret_cast< wxRect * >(argp1);
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (int)((wxRect const *)arg1)->GetX();
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 resultobj = SWIG_From_int(static_cast< int >(result));
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj = 0;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 ;
6390 void *argp1 = 0 ;
6391 int res1 = 0 ;
6392 int val2 ;
6393 int ecode2 = 0 ;
6394 PyObject * obj0 = 0 ;
6395 PyObject * obj1 = 0 ;
6396 char * kwnames[] = {
6397 (char *) "self",(char *) "x", NULL
6398 };
6399
6400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6402 if (!SWIG_IsOK(res1)) {
6403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6404 }
6405 arg1 = reinterpret_cast< wxRect * >(argp1);
6406 ecode2 = SWIG_AsVal_int(obj1, &val2);
6407 if (!SWIG_IsOK(ecode2)) {
6408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6409 }
6410 arg2 = static_cast< int >(val2);
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 (arg1)->SetX(arg2);
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_Py_Void();
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425 PyObject *resultobj = 0;
6426 wxRect *arg1 = (wxRect *) 0 ;
6427 int result;
6428 void *argp1 = 0 ;
6429 int res1 = 0 ;
6430 PyObject *swig_obj[1] ;
6431
6432 if (!args) SWIG_fail;
6433 swig_obj[0] = args;
6434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6437 }
6438 arg1 = reinterpret_cast< wxRect * >(argp1);
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (int)(arg1)->GetY();
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = SWIG_From_int(static_cast< int >(result));
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj = 0;
6454 wxRect *arg1 = (wxRect *) 0 ;
6455 int arg2 ;
6456 void *argp1 = 0 ;
6457 int res1 = 0 ;
6458 int val2 ;
6459 int ecode2 = 0 ;
6460 PyObject * obj0 = 0 ;
6461 PyObject * obj1 = 0 ;
6462 char * kwnames[] = {
6463 (char *) "self",(char *) "y", NULL
6464 };
6465
6466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 ecode2 = SWIG_AsVal_int(obj1, &val2);
6473 if (!SWIG_IsOK(ecode2)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6475 }
6476 arg2 = static_cast< int >(val2);
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 (arg1)->SetY(arg2);
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_Py_Void();
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6491 PyObject *resultobj = 0;
6492 wxRect *arg1 = (wxRect *) 0 ;
6493 int result;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 PyObject *swig_obj[1] ;
6497
6498 if (!args) SWIG_fail;
6499 swig_obj[0] = args;
6500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6503 }
6504 arg1 = reinterpret_cast< wxRect * >(argp1);
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (int)((wxRect const *)arg1)->GetWidth();
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj = 0;
6520 wxRect *arg1 = (wxRect *) 0 ;
6521 int arg2 ;
6522 void *argp1 = 0 ;
6523 int res1 = 0 ;
6524 int val2 ;
6525 int ecode2 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 char * kwnames[] = {
6529 (char *) "self",(char *) "w", NULL
6530 };
6531
6532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 ecode2 = SWIG_AsVal_int(obj1, &val2);
6539 if (!SWIG_IsOK(ecode2)) {
6540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6541 }
6542 arg2 = static_cast< int >(val2);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 (arg1)->SetWidth(arg2);
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 resultobj = SWIG_Py_Void();
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 wxRect *arg1 = (wxRect *) 0 ;
6559 int result;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 PyObject *swig_obj[1] ;
6563
6564 if (!args) SWIG_fail;
6565 swig_obj[0] = args;
6566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6567 if (!SWIG_IsOK(res1)) {
6568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6569 }
6570 arg1 = reinterpret_cast< wxRect * >(argp1);
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (int)((wxRect const *)arg1)->GetHeight();
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 (arg1)->SetHeight(arg2);
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 resultobj = SWIG_Py_Void();
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxPoint result;
6626 void *argp1 = 0 ;
6627 int res1 = 0 ;
6628 PyObject *swig_obj[1] ;
6629
6630 if (!args) SWIG_fail;
6631 swig_obj[0] = args;
6632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = ((wxRect const *)arg1)->GetPosition();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 wxPoint *arg2 = 0 ;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 wxPoint temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char * kwnames[] = {
6660 (char *) "self",(char *) "p", NULL
6661 };
6662
6663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 arg2 = &temp2;
6671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->SetPosition((wxPoint const &)*arg2);
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 resultobj = SWIG_Py_Void();
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687 PyObject *resultobj = 0;
6688 wxRect *arg1 = (wxRect *) 0 ;
6689 wxSize result;
6690 void *argp1 = 0 ;
6691 int res1 = 0 ;
6692 PyObject *swig_obj[1] ;
6693
6694 if (!args) SWIG_fail;
6695 swig_obj[0] = args;
6696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = ((wxRect const *)arg1)->GetSize();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = 0;
6716 wxRect *arg1 = (wxRect *) 0 ;
6717 wxSize *arg2 = 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 wxSize temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char * kwnames[] = {
6724 (char *) "self",(char *) "s", NULL
6725 };
6726
6727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6731 }
6732 arg1 = reinterpret_cast< wxRect * >(argp1);
6733 {
6734 arg2 = &temp2;
6735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 (arg1)->SetSize((wxSize const &)*arg2);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxRect *arg1 = (wxRect *) 0 ;
6753 bool result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (bool)((wxRect const *)arg1)->IsEmpty();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 {
6772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6773 }
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxPoint result;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 PyObject *swig_obj[1] ;
6787
6788 if (!args) SWIG_fail;
6789 swig_obj[0] = args;
6790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 result = ((wxRect const *)arg1)->GetTopLeft();
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 wxPoint *arg2 = 0 ;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 wxPoint temp2 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "p", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 arg2 = &temp2;
6829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = ((wxRect const *)arg1)->GetBottomRight();
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6866 return resultobj;
6867 fail:
6868 return NULL;
6869 }
6870
6871
6872 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj = 0;
6874 wxRect *arg1 = (wxRect *) 0 ;
6875 wxPoint *arg2 = 0 ;
6876 void *argp1 = 0 ;
6877 int res1 = 0 ;
6878 wxPoint temp2 ;
6879 PyObject * obj0 = 0 ;
6880 PyObject * obj1 = 0 ;
6881 char * kwnames[] = {
6882 (char *) "self",(char *) "p", NULL
6883 };
6884
6885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6889 }
6890 arg1 = reinterpret_cast< wxRect * >(argp1);
6891 {
6892 arg2 = &temp2;
6893 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6894 }
6895 {
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909 PyObject *resultobj = 0;
6910 wxRect *arg1 = (wxRect *) 0 ;
6911 wxPoint result;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 PyObject *swig_obj[1] ;
6915
6916 if (!args) SWIG_fail;
6917 swig_obj[0] = args;
6918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6919 if (!SWIG_IsOK(res1)) {
6920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6921 }
6922 arg1 = reinterpret_cast< wxRect * >(argp1);
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = ((wxRect const *)arg1)->GetTopRight();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj = 0;
6938 wxRect *arg1 = (wxRect *) 0 ;
6939 wxPoint *arg2 = 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 wxPoint temp2 ;
6943 PyObject * obj0 = 0 ;
6944 PyObject * obj1 = 0 ;
6945 char * kwnames[] = {
6946 (char *) "self",(char *) "p", NULL
6947 };
6948
6949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 {
6956 arg2 = &temp2;
6957 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6958 }
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 (arg1)->SetTopRight((wxPoint const &)*arg2);
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_Py_Void();
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 wxPoint result;
6976 void *argp1 = 0 ;
6977 int res1 = 0 ;
6978 PyObject *swig_obj[1] ;
6979
6980 if (!args) SWIG_fail;
6981 swig_obj[0] = args;
6982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6985 }
6986 arg1 = reinterpret_cast< wxRect * >(argp1);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = ((wxRect const *)arg1)->GetBottomLeft();
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 wxPoint *arg2 = 0 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 wxPoint temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char * kwnames[] = {
7010 (char *) "self",(char *) "p", NULL
7011 };
7012
7013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7015 if (!SWIG_IsOK(res1)) {
7016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7017 }
7018 arg1 = reinterpret_cast< wxRect * >(argp1);
7019 {
7020 arg2 = &temp2;
7021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7022 }
7023 {
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 resultobj = SWIG_Py_Void();
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7037 PyObject *resultobj = 0;
7038 wxRect *arg1 = (wxRect *) 0 ;
7039 int result;
7040 void *argp1 = 0 ;
7041 int res1 = 0 ;
7042 PyObject *swig_obj[1] ;
7043
7044 if (!args) SWIG_fail;
7045 swig_obj[0] = args;
7046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7047 if (!SWIG_IsOK(res1)) {
7048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7049 }
7050 arg1 = reinterpret_cast< wxRect * >(argp1);
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (int)((wxRect const *)arg1)->GetLeft();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_From_int(static_cast< int >(result));
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int result;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 PyObject *swig_obj[1] ;
7071
7072 if (!args) SWIG_fail;
7073 swig_obj[0] = args;
7074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7075 if (!SWIG_IsOK(res1)) {
7076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7077 }
7078 arg1 = reinterpret_cast< wxRect * >(argp1);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (int)((wxRect const *)arg1)->GetTop();
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_From_int(static_cast< int >(result));
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int result;
7096 void *argp1 = 0 ;
7097 int res1 = 0 ;
7098 PyObject *swig_obj[1] ;
7099
7100 if (!args) SWIG_fail;
7101 swig_obj[0] = args;
7102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7103 if (!SWIG_IsOK(res1)) {
7104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7105 }
7106 arg1 = reinterpret_cast< wxRect * >(argp1);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (int)((wxRect const *)arg1)->GetBottom();
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 resultobj = SWIG_From_int(static_cast< int >(result));
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7121 PyObject *resultobj = 0;
7122 wxRect *arg1 = (wxRect *) 0 ;
7123 int result;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 PyObject *swig_obj[1] ;
7127
7128 if (!args) SWIG_fail;
7129 swig_obj[0] = args;
7130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (int)((wxRect const *)arg1)->GetRight();
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_From_int(static_cast< int >(result));
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "left", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 (arg1)->SetLeft(arg2);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_Py_Void();
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxRect *arg1 = (wxRect *) 0 ;
7189 int arg2 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 int val2 ;
7193 int ecode2 = 0 ;
7194 PyObject * obj0 = 0 ;
7195 PyObject * obj1 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "right", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7204 }
7205 arg1 = reinterpret_cast< wxRect * >(argp1);
7206 ecode2 = SWIG_AsVal_int(obj1, &val2);
7207 if (!SWIG_IsOK(ecode2)) {
7208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7209 }
7210 arg2 = static_cast< int >(val2);
7211 {
7212 PyThreadState* __tstate = wxPyBeginAllowThreads();
7213 (arg1)->SetRight(arg2);
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_Py_Void();
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj = 0;
7226 wxRect *arg1 = (wxRect *) 0 ;
7227 int arg2 ;
7228 void *argp1 = 0 ;
7229 int res1 = 0 ;
7230 int val2 ;
7231 int ecode2 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "top", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 ecode2 = SWIG_AsVal_int(obj1, &val2);
7245 if (!SWIG_IsOK(ecode2)) {
7246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7247 }
7248 arg2 = static_cast< int >(val2);
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 (arg1)->SetTop(arg2);
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxRect *arg1 = (wxRect *) 0 ;
7265 int arg2 ;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 int val2 ;
7269 int ecode2 = 0 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "bottom", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 ecode2 = SWIG_AsVal_int(obj1, &val2);
7283 if (!SWIG_IsOK(ecode2)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7285 }
7286 arg2 = static_cast< int >(val2);
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 (arg1)->SetBottom(arg2);
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 resultobj = SWIG_Py_Void();
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxRect *arg1 = (wxRect *) 0 ;
7303 int arg2 ;
7304 int arg3 ;
7305 wxRect *result = 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 int val2 ;
7309 int ecode2 = 0 ;
7310 int val3 ;
7311 int ecode3 = 0 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 PyObject * obj2 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "self",(char *) "dx",(char *) "dy", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7323 }
7324 arg1 = reinterpret_cast< wxRect * >(argp1);
7325 ecode2 = SWIG_AsVal_int(obj1, &val2);
7326 if (!SWIG_IsOK(ecode2)) {
7327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7328 }
7329 arg2 = static_cast< int >(val2);
7330 ecode3 = SWIG_AsVal_int(obj2, &val3);
7331 if (!SWIG_IsOK(ecode3)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7333 }
7334 arg3 = static_cast< int >(val3);
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 {
7338 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 int arg2 ;
7355 int arg3 ;
7356 wxRect *result = 0 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 int val2 ;
7360 int ecode2 = 0 ;
7361 int val3 ;
7362 int ecode3 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 PyObject * obj2 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "dx",(char *) "dy", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 ecode2 = SWIG_AsVal_int(obj1, &val2);
7377 if (!SWIG_IsOK(ecode2)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7379 }
7380 arg2 = static_cast< int >(val2);
7381 ecode3 = SWIG_AsVal_int(obj2, &val3);
7382 if (!SWIG_IsOK(ecode3)) {
7383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7384 }
7385 arg3 = static_cast< int >(val3);
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 {
7389 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7390 result = (wxRect *) &_result_ref;
7391 }
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7403 PyObject *resultobj = 0;
7404 wxRect *arg1 = (wxRect *) 0 ;
7405 int arg2 ;
7406 int arg3 ;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 int val2 ;
7410 int ecode2 = 0 ;
7411 int val3 ;
7412 int ecode3 = 0 ;
7413 PyObject * obj0 = 0 ;
7414 PyObject * obj1 = 0 ;
7415 PyObject * obj2 = 0 ;
7416 char * kwnames[] = {
7417 (char *) "self",(char *) "dx",(char *) "dy", NULL
7418 };
7419
7420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7424 }
7425 arg1 = reinterpret_cast< wxRect * >(argp1);
7426 ecode2 = SWIG_AsVal_int(obj1, &val2);
7427 if (!SWIG_IsOK(ecode2)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7429 }
7430 arg2 = static_cast< int >(val2);
7431 ecode3 = SWIG_AsVal_int(obj2, &val3);
7432 if (!SWIG_IsOK(ecode3)) {
7433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7434 }
7435 arg3 = static_cast< int >(val3);
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->Offset(arg2,arg3);
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxPoint *arg2 = 0 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxPoint temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "pt", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->Offset((wxPoint const &)*arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxRect *arg1 = (wxRect *) 0 ;
7488 wxRect *arg2 = 0 ;
7489 wxRect result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 wxRect temp2 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "rect", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7503 }
7504 arg1 = reinterpret_cast< wxRect * >(argp1);
7505 {
7506 arg2 = &temp2;
7507 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7508 }
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (arg1)->Intersect((wxRect const &)*arg2);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj = 0;
7524 wxRect *arg1 = (wxRect *) 0 ;
7525 wxRect *arg2 = 0 ;
7526 wxRect result;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 wxRect temp2 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 char * kwnames[] = {
7533 (char *) "self",(char *) "rect", NULL
7534 };
7535
7536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7538 if (!SWIG_IsOK(res1)) {
7539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7540 }
7541 arg1 = reinterpret_cast< wxRect * >(argp1);
7542 {
7543 arg2 = &temp2;
7544 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7545 }
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 result = (arg1)->Union((wxRect const &)*arg2);
7549 wxPyEndAllowThreads(__tstate);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7553 return resultobj;
7554 fail:
7555 return NULL;
7556 }
7557
7558
7559 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7560 PyObject *resultobj = 0;
7561 wxRect *arg1 = (wxRect *) 0 ;
7562 wxRect *arg2 = 0 ;
7563 wxRect result;
7564 void *argp1 = 0 ;
7565 int res1 = 0 ;
7566 wxRect temp2 ;
7567 PyObject * obj0 = 0 ;
7568 PyObject * obj1 = 0 ;
7569 char * kwnames[] = {
7570 (char *) "self",(char *) "rect", NULL
7571 };
7572
7573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7575 if (!SWIG_IsOK(res1)) {
7576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7577 }
7578 arg1 = reinterpret_cast< wxRect * >(argp1);
7579 {
7580 arg2 = &temp2;
7581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7582 }
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7586 wxPyEndAllowThreads(__tstate);
7587 if (PyErr_Occurred()) SWIG_fail;
7588 }
7589 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 wxRect *arg2 = 0 ;
7600 wxRect *result = 0 ;
7601 void *argp1 = 0 ;
7602 int res1 = 0 ;
7603 wxRect temp2 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 char * kwnames[] = {
7607 (char *) "self",(char *) "rect", NULL
7608 };
7609
7610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7612 if (!SWIG_IsOK(res1)) {
7613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7614 }
7615 arg1 = reinterpret_cast< wxRect * >(argp1);
7616 {
7617 arg2 = &temp2;
7618 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7619 }
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 {
7623 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7624 result = (wxRect *) &_result_ref;
7625 }
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj = 0;
7638 wxRect *arg1 = (wxRect *) 0 ;
7639 PyObject *arg2 = (PyObject *) 0 ;
7640 bool result;
7641 void *argp1 = 0 ;
7642 int res1 = 0 ;
7643 PyObject * obj0 = 0 ;
7644 PyObject * obj1 = 0 ;
7645 char * kwnames[] = {
7646 (char *) "self",(char *) "other", NULL
7647 };
7648
7649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7653 }
7654 arg1 = reinterpret_cast< wxRect * >(argp1);
7655 arg2 = obj1;
7656 {
7657 result = (bool)wxRect___eq__(arg1,arg2);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 {
7661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7662 }
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj = 0;
7671 wxRect *arg1 = (wxRect *) 0 ;
7672 PyObject *arg2 = (PyObject *) 0 ;
7673 bool result;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "other", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 arg2 = obj1;
7689 {
7690 result = (bool)wxRect___ne__(arg1,arg2);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int arg2 ;
7706 int arg3 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 int val3 ;
7713 int ecode3 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 PyObject * obj2 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "x",(char *) "y", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7725 }
7726 arg1 = reinterpret_cast< wxRect * >(argp1);
7727 ecode2 = SWIG_AsVal_int(obj1, &val2);
7728 if (!SWIG_IsOK(ecode2)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7730 }
7731 arg2 = static_cast< int >(val2);
7732 ecode3 = SWIG_AsVal_int(obj2, &val3);
7733 if (!SWIG_IsOK(ecode3)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7735 }
7736 arg3 = static_cast< int >(val3);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 wxPoint *arg2 = 0 ;
7756 bool result;
7757 void *argp1 = 0 ;
7758 int res1 = 0 ;
7759 wxPoint temp2 ;
7760 PyObject * obj0 = 0 ;
7761 PyObject * obj1 = 0 ;
7762 char * kwnames[] = {
7763 (char *) "self",(char *) "pt", NULL
7764 };
7765
7766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 {
7773 arg2 = &temp2;
7774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7775 }
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 {
7783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7784 }
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 wxRect *arg2 = 0 ;
7795 bool result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 wxRect temp2 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 char * kwnames[] = {
7802 (char *) "self",(char *) "rect", NULL
7803 };
7804
7805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 arg2 = &temp2;
7813 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7814 }
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7831 PyObject *resultobj = 0;
7832 wxRect *arg1 = (wxRect *) 0 ;
7833 wxRect *arg2 = 0 ;
7834 bool result;
7835 void *argp1 = 0 ;
7836 int res1 = 0 ;
7837 wxRect temp2 ;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 char * kwnames[] = {
7841 (char *) "self",(char *) "rect", NULL
7842 };
7843
7844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7846 if (!SWIG_IsOK(res1)) {
7847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7848 }
7849 arg1 = reinterpret_cast< wxRect * >(argp1);
7850 {
7851 arg2 = &temp2;
7852 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7853 }
7854 {
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7857 wxPyEndAllowThreads(__tstate);
7858 if (PyErr_Occurred()) SWIG_fail;
7859 }
7860 {
7861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7862 }
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj = 0;
7871 wxRect *arg1 = (wxRect *) 0 ;
7872 wxRect *arg2 = 0 ;
7873 int arg3 = (int) wxBOTH ;
7874 wxRect result;
7875 void *argp1 = 0 ;
7876 int res1 = 0 ;
7877 wxRect temp2 ;
7878 int val3 ;
7879 int ecode3 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 PyObject * obj2 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "r",(char *) "dir", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 arg2 = &temp2;
7895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7896 }
7897 if (obj2) {
7898 ecode3 = SWIG_AsVal_int(obj2, &val3);
7899 if (!SWIG_IsOK(ecode3)) {
7900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7901 }
7902 arg3 = static_cast< int >(val3);
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7907 wxPyEndAllowThreads(__tstate);
7908 if (PyErr_Occurred()) SWIG_fail;
7909 }
7910 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7918 PyObject *resultobj = 0;
7919 wxRect *arg1 = (wxRect *) 0 ;
7920 int arg2 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 int val2 ;
7924 int ecode2 = 0 ;
7925 PyObject *swig_obj[2] ;
7926
7927 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7929 if (!SWIG_IsOK(res1)) {
7930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7931 }
7932 arg1 = reinterpret_cast< wxRect * >(argp1);
7933 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7934 if (!SWIG_IsOK(ecode2)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7936 }
7937 arg2 = static_cast< int >(val2);
7938 if (arg1) (arg1)->x = arg2;
7939
7940 resultobj = SWIG_Py_Void();
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7948 PyObject *resultobj = 0;
7949 wxRect *arg1 = (wxRect *) 0 ;
7950 int result;
7951 void *argp1 = 0 ;
7952 int res1 = 0 ;
7953 PyObject *swig_obj[1] ;
7954
7955 if (!args) SWIG_fail;
7956 swig_obj[0] = args;
7957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7958 if (!SWIG_IsOK(res1)) {
7959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7960 }
7961 arg1 = reinterpret_cast< wxRect * >(argp1);
7962 result = (int) ((arg1)->x);
7963 resultobj = SWIG_From_int(static_cast< int >(result));
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 PyObject *resultobj = 0;
7972 wxRect *arg1 = (wxRect *) 0 ;
7973 int arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 int val2 ;
7977 int ecode2 = 0 ;
7978 PyObject *swig_obj[2] ;
7979
7980 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7984 }
7985 arg1 = reinterpret_cast< wxRect * >(argp1);
7986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7989 }
7990 arg2 = static_cast< int >(val2);
7991 if (arg1) (arg1)->y = arg2;
7992
7993 resultobj = SWIG_Py_Void();
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8001 PyObject *resultobj = 0;
8002 wxRect *arg1 = (wxRect *) 0 ;
8003 int result;
8004 void *argp1 = 0 ;
8005 int res1 = 0 ;
8006 PyObject *swig_obj[1] ;
8007
8008 if (!args) SWIG_fail;
8009 swig_obj[0] = args;
8010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8011 if (!SWIG_IsOK(res1)) {
8012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8013 }
8014 arg1 = reinterpret_cast< wxRect * >(argp1);
8015 result = (int) ((arg1)->y);
8016 resultobj = SWIG_From_int(static_cast< int >(result));
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxRect *arg1 = (wxRect *) 0 ;
8026 int arg2 ;
8027 void *argp1 = 0 ;
8028 int res1 = 0 ;
8029 int val2 ;
8030 int ecode2 = 0 ;
8031 PyObject *swig_obj[2] ;
8032
8033 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8040 if (!SWIG_IsOK(ecode2)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8042 }
8043 arg2 = static_cast< int >(val2);
8044 if (arg1) (arg1)->width = arg2;
8045
8046 resultobj = SWIG_Py_Void();
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxRect *arg1 = (wxRect *) 0 ;
8056 int result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8066 }
8067 arg1 = reinterpret_cast< wxRect * >(argp1);
8068 result = (int) ((arg1)->width);
8069 resultobj = SWIG_From_int(static_cast< int >(result));
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8077 PyObject *resultobj = 0;
8078 wxRect *arg1 = (wxRect *) 0 ;
8079 int arg2 ;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 int val2 ;
8083 int ecode2 = 0 ;
8084 PyObject *swig_obj[2] ;
8085
8086 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8090 }
8091 arg1 = reinterpret_cast< wxRect * >(argp1);
8092 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 if (arg1) (arg1)->height = arg2;
8098
8099 resultobj = SWIG_Py_Void();
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxRect *arg1 = (wxRect *) 0 ;
8109 int result;
8110 void *argp1 = 0 ;
8111 int res1 = 0 ;
8112 PyObject *swig_obj[1] ;
8113
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8119 }
8120 arg1 = reinterpret_cast< wxRect * >(argp1);
8121 result = (int) ((arg1)->height);
8122 resultobj = SWIG_From_int(static_cast< int >(result));
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxRect *arg1 = (wxRect *) 0 ;
8132 int arg2 = (int) 0 ;
8133 int arg3 = (int) 0 ;
8134 int arg4 = (int) 0 ;
8135 int arg5 = (int) 0 ;
8136 void *argp1 = 0 ;
8137 int res1 = 0 ;
8138 int val2 ;
8139 int ecode2 = 0 ;
8140 int val3 ;
8141 int ecode3 = 0 ;
8142 int val4 ;
8143 int ecode4 = 0 ;
8144 int val5 ;
8145 int ecode5 = 0 ;
8146 PyObject * obj0 = 0 ;
8147 PyObject * obj1 = 0 ;
8148 PyObject * obj2 = 0 ;
8149 PyObject * obj3 = 0 ;
8150 PyObject * obj4 = 0 ;
8151 char * kwnames[] = {
8152 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8153 };
8154
8155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 if (obj1) {
8162 ecode2 = SWIG_AsVal_int(obj1, &val2);
8163 if (!SWIG_IsOK(ecode2)) {
8164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8165 }
8166 arg2 = static_cast< int >(val2);
8167 }
8168 if (obj2) {
8169 ecode3 = SWIG_AsVal_int(obj2, &val3);
8170 if (!SWIG_IsOK(ecode3)) {
8171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8172 }
8173 arg3 = static_cast< int >(val3);
8174 }
8175 if (obj3) {
8176 ecode4 = SWIG_AsVal_int(obj3, &val4);
8177 if (!SWIG_IsOK(ecode4)) {
8178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8179 }
8180 arg4 = static_cast< int >(val4);
8181 }
8182 if (obj4) {
8183 ecode5 = SWIG_AsVal_int(obj4, &val5);
8184 if (!SWIG_IsOK(ecode5)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8186 }
8187 arg5 = static_cast< int >(val5);
8188 }
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8203 PyObject *resultobj = 0;
8204 wxRect *arg1 = (wxRect *) 0 ;
8205 PyObject *result = 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8215 }
8216 arg1 = reinterpret_cast< wxRect * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 result = (PyObject *)wxRect_Get(arg1);
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 resultobj = result;
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8231 PyObject *obj;
8232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8233 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8234 return SWIG_Py_Void();
8235 }
8236
8237 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8238 return SWIG_Python_InitShadowInstance(args);
8239 }
8240
8241 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj = 0;
8243 wxRect *arg1 = (wxRect *) 0 ;
8244 wxRect *arg2 = (wxRect *) 0 ;
8245 PyObject *result = 0 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 void *argp2 = 0 ;
8249 int res2 = 0 ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "r1",(char *) "r2", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8260 }
8261 arg1 = reinterpret_cast< wxRect * >(argp1);
8262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8263 if (!SWIG_IsOK(res2)) {
8264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8265 }
8266 arg2 = reinterpret_cast< wxRect * >(argp2);
8267 {
8268 if (!wxPyCheckForApp()) SWIG_fail;
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (PyObject *)wxIntersectRect(arg1,arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = result;
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 double arg1 = (double) 0.0 ;
8284 double arg2 = (double) 0.0 ;
8285 wxPoint2D *result = 0 ;
8286 double val1 ;
8287 int ecode1 = 0 ;
8288 double val2 ;
8289 int ecode2 = 0 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "x",(char *) "y", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8297 if (obj0) {
8298 ecode1 = SWIG_AsVal_double(obj0, &val1);
8299 if (!SWIG_IsOK(ecode1)) {
8300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8301 }
8302 arg1 = static_cast< double >(val1);
8303 }
8304 if (obj1) {
8305 ecode2 = SWIG_AsVal_double(obj1, &val2);
8306 if (!SWIG_IsOK(ecode2)) {
8307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8308 }
8309 arg2 = static_cast< double >(val2);
8310 }
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = 0 ;
8327 wxPoint2D *result = 0 ;
8328 wxPoint2D temp1 ;
8329 PyObject * obj0 = 0 ;
8330 char * kwnames[] = {
8331 (char *) "pt", NULL
8332 };
8333
8334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8335 {
8336 arg1 = &temp1;
8337 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxPoint *arg1 = 0 ;
8355 wxPoint2D *result = 0 ;
8356 wxPoint temp1 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "pt", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8363 {
8364 arg1 = &temp1;
8365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8366 }
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8381 PyObject *resultobj = 0;
8382 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 PyObject *swig_obj[1] ;
8386
8387 if (!args) SWIG_fail;
8388 swig_obj[0] = args;
8389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8390 if (!SWIG_IsOK(res1)) {
8391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8392 }
8393 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 delete arg1;
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 resultobj = SWIG_Py_Void();
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8409 PyObject *resultobj = 0;
8410 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8411 int *arg2 = (int *) 0 ;
8412 int *arg3 = (int *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 int temp2 ;
8416 int res2 = SWIG_TMPOBJ ;
8417 int temp3 ;
8418 int res3 = SWIG_TMPOBJ ;
8419 PyObject *swig_obj[1] ;
8420
8421 arg2 = &temp2;
8422 arg3 = &temp3;
8423 if (!args) SWIG_fail;
8424 swig_obj[0] = args;
8425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8428 }
8429 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 resultobj = SWIG_Py_Void();
8437 if (SWIG_IsTmpObj(res2)) {
8438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8439 } else {
8440 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8442 }
8443 if (SWIG_IsTmpObj(res3)) {
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8445 } else {
8446 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8448 }
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8458 int *arg2 = (int *) 0 ;
8459 int *arg3 = (int *) 0 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int temp2 ;
8463 int res2 = SWIG_TMPOBJ ;
8464 int temp3 ;
8465 int res3 = SWIG_TMPOBJ ;
8466 PyObject *swig_obj[1] ;
8467
8468 arg2 = &temp2;
8469 arg3 = &temp3;
8470 if (!args) SWIG_fail;
8471 swig_obj[0] = args;
8472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 double result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_From_double(static_cast< double >(result));
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 double arg2 ;
8562 void *argp1 = 0 ;
8563 int res1 = 0 ;
8564 double val2 ;
8565 int ecode2 = 0 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "length", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 ecode2 = SWIG_AsVal_double(obj1, &val2);
8579 if (!SWIG_IsOK(ecode2)) {
8580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8581 }
8582 arg2 = static_cast< double >(val2);
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 (arg1)->SetVectorLength(arg2);
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_Py_Void();
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8599 double arg2 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 double val2 ;
8603 int ecode2 = 0 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char * kwnames[] = {
8607 (char *) "self",(char *) "degrees", NULL
8608 };
8609
8610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8614 }
8615 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8616 ecode2 = SWIG_AsVal_double(obj1, &val2);
8617 if (!SWIG_IsOK(ecode2)) {
8618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8619 }
8620 arg2 = static_cast< double >(val2);
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 (arg1)->SetVectorAngle(arg2);
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 double result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_From_double(static_cast< double >(result));
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj = 0;
8673 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8674 wxPoint2D *arg2 = 0 ;
8675 double result;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 wxPoint2D temp2 ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char * kwnames[] = {
8682 (char *) "self",(char *) "pt", NULL
8683 };
8684
8685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8689 }
8690 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8691 {
8692 arg2 = &temp2;
8693 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8694 }
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_From_double(static_cast< double >(result));
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 wxPoint2D *arg2 = 0 ;
8712 double result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 wxPoint2D temp2 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 char * kwnames[] = {
8719 (char *) "self",(char *) "vec", NULL
8720 };
8721
8722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 {
8729 arg2 = &temp2;
8730 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8731 }
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_From_double(static_cast< double >(result));
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj = 0;
8747 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8748 wxPoint2D *arg2 = 0 ;
8749 double result;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 wxPoint2D temp2 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 char * kwnames[] = {
8756 (char *) "self",(char *) "vec", NULL
8757 };
8758
8759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8761 if (!SWIG_IsOK(res1)) {
8762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8763 }
8764 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8765 {
8766 arg2 = &temp2;
8767 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_From_double(static_cast< double >(result));
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D result;
8786 void *argp1 = 0 ;
8787 int res1 = 0 ;
8788 PyObject *swig_obj[1] ;
8789
8790 if (!args) SWIG_fail;
8791 swig_obj[0] = args;
8792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 {
8798 PyThreadState* __tstate = wxPyBeginAllowThreads();
8799 result = (arg1)->operator -();
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8813 wxPoint2D *arg2 = 0 ;
8814 wxPoint2D *result = 0 ;
8815 void *argp1 = 0 ;
8816 int res1 = 0 ;
8817 wxPoint2D temp2 ;
8818 PyObject * obj0 = 0 ;
8819 PyObject * obj1 = 0 ;
8820 char * kwnames[] = {
8821 (char *) "self",(char *) "pt", NULL
8822 };
8823
8824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8828 }
8829 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8830 {
8831 arg2 = &temp2;
8832 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 {
8837 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8838 result = (wxPoint2D *) &_result_ref;
8839 }
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj = 0;
8852 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8853 wxPoint2D *arg2 = 0 ;
8854 wxPoint2D *result = 0 ;
8855 void *argp1 = 0 ;
8856 int res1 = 0 ;
8857 wxPoint2D temp2 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "pt", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8868 }
8869 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8870 {
8871 arg2 = &temp2;
8872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8873 }
8874 {
8875 PyThreadState* __tstate = wxPyBeginAllowThreads();
8876 {
8877 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8878 result = (wxPoint2D *) &_result_ref;
8879 }
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 wxPoint2D *arg2 = 0 ;
8894 wxPoint2D *result = 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 wxPoint2D temp2 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "pt", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 {
8911 arg2 = &temp2;
8912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 {
8917 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8918 result = (wxPoint2D *) &_result_ref;
8919 }
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = 0;
8932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8933 wxPoint2D *arg2 = 0 ;
8934 wxPoint2D *result = 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 wxPoint2D temp2 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 char * kwnames[] = {
8941 (char *) "self",(char *) "pt", NULL
8942 };
8943
8944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8948 }
8949 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8950 {
8951 arg2 = &temp2;
8952 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8953 }
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 {
8957 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8958 result = (wxPoint2D *) &_result_ref;
8959 }
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 PyObject *arg2 = (PyObject *) 0 ;
8974 bool result;
8975 void *argp1 = 0 ;
8976 int res1 = 0 ;
8977 PyObject * obj0 = 0 ;
8978 PyObject * obj1 = 0 ;
8979 char * kwnames[] = {
8980 (char *) "self",(char *) "other", NULL
8981 };
8982
8983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8985 if (!SWIG_IsOK(res1)) {
8986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8987 }
8988 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8989 arg2 = obj1;
8990 {
8991 result = (bool)wxPoint2D___eq__(arg1,arg2);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 {
8995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8996 }
8997 return resultobj;
8998 fail:
8999 return NULL;
9000 }
9001
9002
9003 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9004 PyObject *resultobj = 0;
9005 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9006 PyObject *arg2 = (PyObject *) 0 ;
9007 bool result;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 PyObject * obj1 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "self",(char *) "other", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 arg2 = obj1;
9023 {
9024 result = (bool)wxPoint2D___ne__(arg1,arg2);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 {
9028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9029 }
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037 PyObject *resultobj = 0;
9038 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9039 double arg2 ;
9040 void *argp1 = 0 ;
9041 int res1 = 0 ;
9042 double val2 ;
9043 int ecode2 = 0 ;
9044 PyObject *swig_obj[2] ;
9045
9046 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9050 }
9051 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9052 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9053 if (!SWIG_IsOK(ecode2)) {
9054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9055 }
9056 arg2 = static_cast< double >(val2);
9057 if (arg1) (arg1)->m_x = arg2;
9058
9059 resultobj = SWIG_Py_Void();
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9069 double result;
9070 void *argp1 = 0 ;
9071 int res1 = 0 ;
9072 PyObject *swig_obj[1] ;
9073
9074 if (!args) SWIG_fail;
9075 swig_obj[0] = args;
9076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9077 if (!SWIG_IsOK(res1)) {
9078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9079 }
9080 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9081 result = (double) ((arg1)->m_x);
9082 resultobj = SWIG_From_double(static_cast< double >(result));
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 PyObject *resultobj = 0;
9091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9092 double arg2 ;
9093 void *argp1 = 0 ;
9094 int res1 = 0 ;
9095 double val2 ;
9096 int ecode2 = 0 ;
9097 PyObject *swig_obj[2] ;
9098
9099 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9105 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9108 }
9109 arg2 = static_cast< double >(val2);
9110 if (arg1) (arg1)->m_y = arg2;
9111
9112 resultobj = SWIG_Py_Void();
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 PyObject *resultobj = 0;
9121 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9122 double result;
9123 void *argp1 = 0 ;
9124 int res1 = 0 ;
9125 PyObject *swig_obj[1] ;
9126
9127 if (!args) SWIG_fail;
9128 swig_obj[0] = args;
9129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9130 if (!SWIG_IsOK(res1)) {
9131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9132 }
9133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9134 result = (double) ((arg1)->m_y);
9135 resultobj = SWIG_From_double(static_cast< double >(result));
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9145 double arg2 = (double) 0 ;
9146 double arg3 = (double) 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 double val2 ;
9150 int ecode2 = 0 ;
9151 double val3 ;
9152 int ecode3 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 PyObject * obj2 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "self",(char *) "x",(char *) "y", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9164 }
9165 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9166 if (obj1) {
9167 ecode2 = SWIG_AsVal_double(obj1, &val2);
9168 if (!SWIG_IsOK(ecode2)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9170 }
9171 arg2 = static_cast< double >(val2);
9172 }
9173 if (obj2) {
9174 ecode3 = SWIG_AsVal_double(obj2, &val3);
9175 if (!SWIG_IsOK(ecode3)) {
9176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9177 }
9178 arg3 = static_cast< double >(val3);
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 wxPoint2D_Set(arg1,arg2,arg3);
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 resultobj = SWIG_Py_Void();
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 PyObject *resultobj = 0;
9195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9196 PyObject *result = 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 PyObject *swig_obj[1] ;
9200
9201 if (!args) SWIG_fail;
9202 swig_obj[0] = args;
9203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9204 if (!SWIG_IsOK(res1)) {
9205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9206 }
9207 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 result = (PyObject *)wxPoint2D_Get(arg1);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = result;
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *obj;
9223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9224 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9225 return SWIG_Py_Void();
9226 }
9227
9228 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 return SWIG_Python_InitShadowInstance(args);
9230 }
9231
9232 SWIGINTERN int DefaultPosition_set(PyObject *) {
9233 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9234 return 1;
9235 }
9236
9237
9238 SWIGINTERN PyObject *DefaultPosition_get(void) {
9239 PyObject *pyobj = 0;
9240
9241 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9242 return pyobj;
9243 }
9244
9245
9246 SWIGINTERN int DefaultSize_set(PyObject *) {
9247 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9248 return 1;
9249 }
9250
9251
9252 SWIGINTERN PyObject *DefaultSize_get(void) {
9253 PyObject *pyobj = 0;
9254
9255 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9256 return pyobj;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj = 0;
9262 PyObject *arg1 = (PyObject *) 0 ;
9263 wxPyInputStream *result = 0 ;
9264 PyObject * obj0 = 0 ;
9265 char * kwnames[] = {
9266 (char *) "p", NULL
9267 };
9268
9269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9270 arg1 = obj0;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9296 }
9297 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9324 }
9325 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->close();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9351 }
9352 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 (arg1)->flush();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_Py_Void();
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9369 bool result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9379 }
9380 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (bool)(arg1)->eof();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9399 int arg2 = (int) -1 ;
9400 PyObject *result = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 int val2 ;
9404 int ecode2 = 0 ;
9405 PyObject * obj0 = 0 ;
9406 PyObject * obj1 = 0 ;
9407 char * kwnames[] = {
9408 (char *) "self",(char *) "size", NULL
9409 };
9410
9411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9413 if (!SWIG_IsOK(res1)) {
9414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9415 }
9416 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9417 if (obj1) {
9418 ecode2 = SWIG_AsVal_int(obj1, &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9421 }
9422 arg2 = static_cast< int >(val2);
9423 }
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (PyObject *)(arg1)->read(arg2);
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = result;
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9440 int arg2 = (int) -1 ;
9441 PyObject *result = 0 ;
9442 void *argp1 = 0 ;
9443 int res1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "self",(char *) "size", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 if (obj1) {
9459 ecode2 = SWIG_AsVal_int(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9462 }
9463 arg2 = static_cast< int >(val2);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (PyObject *)(arg1)->readline(arg2);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = result;
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9479 PyObject *resultobj = 0;
9480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9481 int arg2 = (int) -1 ;
9482 PyObject *result = 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 int val2 ;
9486 int ecode2 = 0 ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 char * kwnames[] = {
9490 (char *) "self",(char *) "sizehint", NULL
9491 };
9492
9493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9497 }
9498 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9499 if (obj1) {
9500 ecode2 = SWIG_AsVal_int(obj1, &val2);
9501 if (!SWIG_IsOK(ecode2)) {
9502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9503 }
9504 arg2 = static_cast< int >(val2);
9505 }
9506 {
9507 PyThreadState* __tstate = wxPyBeginAllowThreads();
9508 result = (PyObject *)(arg1)->readlines(arg2);
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = result;
9513 return resultobj;
9514 fail:
9515 return NULL;
9516 }
9517
9518
9519 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9520 PyObject *resultobj = 0;
9521 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9522 int arg2 ;
9523 int arg3 = (int) 0 ;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 int val2 ;
9527 int ecode2 = 0 ;
9528 int val3 ;
9529 int ecode3 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 PyObject * obj2 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "offset",(char *) "whence", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9541 }
9542 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9543 ecode2 = SWIG_AsVal_int(obj1, &val2);
9544 if (!SWIG_IsOK(ecode2)) {
9545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9546 }
9547 arg2 = static_cast< int >(val2);
9548 if (obj2) {
9549 ecode3 = SWIG_AsVal_int(obj2, &val3);
9550 if (!SWIG_IsOK(ecode3)) {
9551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9552 }
9553 arg3 = static_cast< int >(val3);
9554 }
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 (arg1)->seek(arg2,arg3);
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_Py_Void();
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569 PyObject *resultobj = 0;
9570 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9571 int result;
9572 void *argp1 = 0 ;
9573 int res1 = 0 ;
9574 PyObject *swig_obj[1] ;
9575
9576 if (!args) SWIG_fail;
9577 swig_obj[0] = args;
9578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9579 if (!SWIG_IsOK(res1)) {
9580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9581 }
9582 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (int)(arg1)->tell();
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_From_int(static_cast< int >(result));
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9597 PyObject *resultobj = 0;
9598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9599 char result;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 PyObject *swig_obj[1] ;
9603
9604 if (!args) SWIG_fail;
9605 swig_obj[0] = args;
9606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9609 }
9610 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (char)(arg1)->Peek();
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 resultobj = SWIG_From_char(static_cast< char >(result));
9618 return resultobj;
9619 fail:
9620 return NULL;
9621 }
9622
9623
9624 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9625 PyObject *resultobj = 0;
9626 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9627 char result;
9628 void *argp1 = 0 ;
9629 int res1 = 0 ;
9630 PyObject *swig_obj[1] ;
9631
9632 if (!args) SWIG_fail;
9633 swig_obj[0] = args;
9634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9635 if (!SWIG_IsOK(res1)) {
9636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9637 }
9638 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (char)(arg1)->GetC();
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_From_char(static_cast< char >(result));
9646 return resultobj;
9647 fail:
9648 return NULL;
9649 }
9650
9651
9652 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9653 PyObject *resultobj = 0;
9654 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9655 size_t result;
9656 void *argp1 = 0 ;
9657 int res1 = 0 ;
9658 PyObject *swig_obj[1] ;
9659
9660 if (!args) SWIG_fail;
9661 swig_obj[0] = args;
9662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9663 if (!SWIG_IsOK(res1)) {
9664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9665 }
9666 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (size_t)(arg1)->LastRead();
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 PyObject *resultobj = 0;
9682 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9683 bool result;
9684 void *argp1 = 0 ;
9685 int res1 = 0 ;
9686 PyObject *swig_obj[1] ;
9687
9688 if (!args) SWIG_fail;
9689 swig_obj[0] = args;
9690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9693 }
9694 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (bool)(arg1)->CanRead();
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 {
9702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9703 }
9704 return resultobj;
9705 fail:
9706 return NULL;
9707 }
9708
9709
9710 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9711 PyObject *resultobj = 0;
9712 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9713 bool result;
9714 void *argp1 = 0 ;
9715 int res1 = 0 ;
9716 PyObject *swig_obj[1] ;
9717
9718 if (!args) SWIG_fail;
9719 swig_obj[0] = args;
9720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9721 if (!SWIG_IsOK(res1)) {
9722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9723 }
9724 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (bool)(arg1)->Eof();
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = 0;
9742 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9743 char arg2 ;
9744 bool result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 char val2 ;
9748 int ecode2 = 0 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char * kwnames[] = {
9752 (char *) "self",(char *) "c", NULL
9753 };
9754
9755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9757 if (!SWIG_IsOK(res1)) {
9758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9759 }
9760 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9761 ecode2 = SWIG_AsVal_char(obj1, &val2);
9762 if (!SWIG_IsOK(ecode2)) {
9763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9764 }
9765 arg2 = static_cast< char >(val2);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (bool)(arg1)->Ungetch(arg2);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 {
9773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9774 }
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = 0;
9783 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9784 long arg2 ;
9785 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9786 long result;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 long val2 ;
9790 int ecode2 = 0 ;
9791 int val3 ;
9792 int ecode3 = 0 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 PyObject * obj2 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pos",(char *) "mode", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9804 }
9805 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9806 ecode2 = SWIG_AsVal_long(obj1, &val2);
9807 if (!SWIG_IsOK(ecode2)) {
9808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9809 }
9810 arg2 = static_cast< long >(val2);
9811 if (obj2) {
9812 ecode3 = SWIG_AsVal_int(obj2, &val3);
9813 if (!SWIG_IsOK(ecode3)) {
9814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9815 }
9816 arg3 = static_cast< wxSeekMode >(val3);
9817 }
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (long)(arg1)->SeekI(arg2,arg3);
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_From_long(static_cast< long >(result));
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9834 long result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9844 }
9845 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (long)(arg1)->TellI();
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 resultobj = SWIG_From_long(static_cast< long >(result));
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *obj;
9861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9863 return SWIG_Py_Void();
9864 }
9865
9866 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 return SWIG_Python_InitShadowInstance(args);
9868 }
9869
9870 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj = 0;
9872 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9873 PyObject *arg2 = (PyObject *) 0 ;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 PyObject * obj0 = 0 ;
9877 PyObject * obj1 = 0 ;
9878 char * kwnames[] = {
9879 (char *) "self",(char *) "obj", NULL
9880 };
9881
9882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9884 if (!SWIG_IsOK(res1)) {
9885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9886 }
9887 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9888 arg2 = obj1;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 wxOutputStream_write(arg1,arg2);
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 resultobj = SWIG_Py_Void();
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9905 size_t result;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9915 }
9916 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj = 0;
9939 wxInputStream *arg1 = (wxInputStream *) 0 ;
9940 wxString *arg2 = 0 ;
9941 wxString *arg3 = 0 ;
9942 wxString *arg4 = 0 ;
9943 wxDateTime arg5 ;
9944 wxFSFile *result = 0 ;
9945 wxPyInputStream *temp1 ;
9946 bool temp2 = false ;
9947 bool temp3 = false ;
9948 bool temp4 = false ;
9949 void *argp5 ;
9950 int res5 = 0 ;
9951 PyObject * obj0 = 0 ;
9952 PyObject * obj1 = 0 ;
9953 PyObject * obj2 = 0 ;
9954 PyObject * obj3 = 0 ;
9955 PyObject * obj4 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9961 {
9962 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9963 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9964 } else {
9965 PyErr_Clear(); // clear the failure of the wxPyConvert above
9966 arg1 = wxPyCBInputStream_create(obj0, true);
9967 if (arg1 == NULL) {
9968 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9969 SWIG_fail;
9970 }
9971 }
9972 }
9973 {
9974 arg2 = wxString_in_helper(obj1);
9975 if (arg2 == NULL) SWIG_fail;
9976 temp2 = true;
9977 }
9978 {
9979 arg3 = wxString_in_helper(obj2);
9980 if (arg3 == NULL) SWIG_fail;
9981 temp3 = true;
9982 }
9983 {
9984 arg4 = wxString_in_helper(obj3);
9985 if (arg4 == NULL) SWIG_fail;
9986 temp4 = true;
9987 }
9988 {
9989 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9990 if (!SWIG_IsOK(res5)) {
9991 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9992 }
9993 if (!argp5) {
9994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9995 } else {
9996 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9997 arg5 = *temp;
9998 if (SWIG_IsNewObj(res5)) delete temp;
9999 }
10000 }
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10004 wxPyEndAllowThreads(__tstate);
10005 if (PyErr_Occurred()) SWIG_fail;
10006 }
10007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10008 {
10009 if (temp2)
10010 delete arg2;
10011 }
10012 {
10013 if (temp3)
10014 delete arg3;
10015 }
10016 {
10017 if (temp4)
10018 delete arg4;
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 {
10027 if (temp3)
10028 delete arg3;
10029 }
10030 {
10031 if (temp4)
10032 delete arg4;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 PyObject *resultobj = 0;
10040 wxFSFile *arg1 = (wxFSFile *) 0 ;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 PyObject *swig_obj[1] ;
10044
10045 if (!args) SWIG_fail;
10046 swig_obj[0] = args;
10047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10050 }
10051 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 delete arg1;
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 resultobj = SWIG_Py_Void();
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 PyObject *resultobj = 0;
10068 wxFSFile *arg1 = (wxFSFile *) 0 ;
10069 wxInputStream *result = 0 ;
10070 void *argp1 = 0 ;
10071 int res1 = 0 ;
10072 PyObject *swig_obj[1] ;
10073
10074 if (!args) SWIG_fail;
10075 swig_obj[0] = args;
10076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10077 if (!SWIG_IsOK(res1)) {
10078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10079 }
10080 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxInputStream *)(arg1)->GetStream();
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 wxPyInputStream * _ptr = NULL;
10089
10090 if (result) {
10091 _ptr = new wxPyInputStream(result);
10092 }
10093 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10094 }
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102 PyObject *resultobj = 0;
10103 wxFSFile *arg1 = (wxFSFile *) 0 ;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 PyObject *swig_obj[1] ;
10107
10108 if (!args) SWIG_fail;
10109 swig_obj[0] = args;
10110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10113 }
10114 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->DetachStream();
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 resultobj = SWIG_Py_Void();
10122 return resultobj;
10123 fail:
10124 return NULL;
10125 }
10126
10127
10128 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10129 PyObject *resultobj = 0;
10130 wxFSFile *arg1 = (wxFSFile *) 0 ;
10131 wxString *result = 0 ;
10132 void *argp1 = 0 ;
10133 int res1 = 0 ;
10134 PyObject *swig_obj[1] ;
10135
10136 if (!args) SWIG_fail;
10137 swig_obj[0] = args;
10138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10141 }
10142 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 {
10146 wxString const &_result_ref = (arg1)->GetMimeType();
10147 result = (wxString *) &_result_ref;
10148 }
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 {
10153 #if wxUSE_UNICODE
10154 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10155 #else
10156 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10157 #endif
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 PyObject *resultobj = 0;
10167 wxFSFile *arg1 = (wxFSFile *) 0 ;
10168 wxString *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 PyObject *swig_obj[1] ;
10172
10173 if (!args) SWIG_fail;
10174 swig_obj[0] = args;
10175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10178 }
10179 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 {
10183 wxString const &_result_ref = (arg1)->GetLocation();
10184 result = (wxString *) &_result_ref;
10185 }
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 #if wxUSE_UNICODE
10191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10192 #else
10193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10194 #endif
10195 }
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10203 PyObject *resultobj = 0;
10204 wxFSFile *arg1 = (wxFSFile *) 0 ;
10205 wxString *result = 0 ;
10206 void *argp1 = 0 ;
10207 int res1 = 0 ;
10208 PyObject *swig_obj[1] ;
10209
10210 if (!args) SWIG_fail;
10211 swig_obj[0] = args;
10212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10213 if (!SWIG_IsOK(res1)) {
10214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10215 }
10216 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 {
10220 wxString const &_result_ref = (arg1)->GetAnchor();
10221 result = (wxString *) &_result_ref;
10222 }
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 #if wxUSE_UNICODE
10228 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10229 #else
10230 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10231 #endif
10232 }
10233 return resultobj;
10234 fail:
10235 return NULL;
10236 }
10237
10238
10239 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10240 PyObject *resultobj = 0;
10241 wxFSFile *arg1 = (wxFSFile *) 0 ;
10242 wxDateTime result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 PyObject *swig_obj[1] ;
10246
10247 if (!args) SWIG_fail;
10248 swig_obj[0] = args;
10249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10252 }
10253 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (arg1)->GetModificationTime();
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10261 return resultobj;
10262 fail:
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10268 PyObject *obj;
10269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10270 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10271 return SWIG_Py_Void();
10272 }
10273
10274 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 return SWIG_Python_InitShadowInstance(args);
10276 }
10277
10278 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *resultobj = 0;
10280 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10281 void *argp1 = 0 ;
10282 int res1 = 0 ;
10283 PyObject *swig_obj[1] ;
10284
10285 if (!args) SWIG_fail;
10286 swig_obj[0] = args;
10287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10288 if (!SWIG_IsOK(res1)) {
10289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10290 }
10291 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 delete arg1;
10295
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_Py_Void();
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10307 PyObject *obj;
10308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10309 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10310 return SWIG_Py_Void();
10311 }
10312
10313 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314 PyObject *resultobj = 0;
10315 wxPyFileSystemHandler *result = 0 ;
10316
10317 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10325 return resultobj;
10326 fail:
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10334 PyObject *arg2 = (PyObject *) 0 ;
10335 PyObject *arg3 = (PyObject *) 0 ;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "self",(char *) "_class", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10351 arg2 = obj1;
10352 arg3 = obj2;
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 (arg1)->_setCallbackInfo(arg2,arg3);
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 resultobj = SWIG_Py_Void();
10360 return resultobj;
10361 fail:
10362 return NULL;
10363 }
10364
10365
10366 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = 0;
10368 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10369 wxString *arg2 = 0 ;
10370 bool result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 bool temp2 = false ;
10374 PyObject * obj0 = 0 ;
10375 PyObject * obj1 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "location", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10386 {
10387 arg2 = wxString_in_helper(obj1);
10388 if (arg2 == NULL) SWIG_fail;
10389 temp2 = true;
10390 }
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 {
10398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10399 }
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return resultobj;
10405 fail:
10406 {
10407 if (temp2)
10408 delete arg2;
10409 }
10410 return NULL;
10411 }
10412
10413
10414 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj = 0;
10416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10417 wxFileSystem *arg2 = 0 ;
10418 wxString *arg3 = 0 ;
10419 wxFSFile *result = 0 ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 void *argp2 = 0 ;
10423 int res2 = 0 ;
10424 bool temp3 = false ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "fs",(char *) "location", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10436 }
10437 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10439 if (!SWIG_IsOK(res2)) {
10440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10441 }
10442 if (!argp2) {
10443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10444 }
10445 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10446 {
10447 arg3 = wxString_in_helper(obj2);
10448 if (arg3 == NULL) SWIG_fail;
10449 temp3 = true;
10450 }
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10459 }
10460 {
10461 if (temp3)
10462 delete arg3;
10463 }
10464 return resultobj;
10465 fail:
10466 {
10467 if (temp3)
10468 delete arg3;
10469 }
10470 return NULL;
10471 }
10472
10473
10474 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj = 0;
10476 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10477 wxString *arg2 = 0 ;
10478 int arg3 = (int) 0 ;
10479 wxString result;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 bool temp2 = false ;
10483 int val3 ;
10484 int ecode3 = 0 ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 char * kwnames[] = {
10489 (char *) "self",(char *) "spec",(char *) "flags", NULL
10490 };
10491
10492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10498 {
10499 arg2 = wxString_in_helper(obj1);
10500 if (arg2 == NULL) SWIG_fail;
10501 temp2 = true;
10502 }
10503 if (obj2) {
10504 ecode3 = SWIG_AsVal_int(obj2, &val3);
10505 if (!SWIG_IsOK(ecode3)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10507 }
10508 arg3 = static_cast< int >(val3);
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 #if wxUSE_UNICODE
10518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10519 #else
10520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10521 #endif
10522 }
10523 {
10524 if (temp2)
10525 delete arg2;
10526 }
10527 return resultobj;
10528 fail:
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return NULL;
10534 }
10535
10536
10537 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538 PyObject *resultobj = 0;
10539 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10540 wxString result;
10541 void *argp1 = 0 ;
10542 int res1 = 0 ;
10543 PyObject *swig_obj[1] ;
10544
10545 if (!args) SWIG_fail;
10546 swig_obj[0] = args;
10547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10548 if (!SWIG_IsOK(res1)) {
10549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10550 }
10551 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (arg1)->FindNext();
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 {
10559 #if wxUSE_UNICODE
10560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10561 #else
10562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10563 #endif
10564 }
10565 return resultobj;
10566 fail:
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj = 0;
10573 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10574 wxString *arg2 = 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 bool temp2 = false ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (arg1)->GetProtocol((wxString const &)*arg2);
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 {
10603 #if wxUSE_UNICODE
10604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10605 #else
10606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10607 #endif
10608 }
10609 {
10610 if (temp2)
10611 delete arg2;
10612 }
10613 return resultobj;
10614 fail:
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj = 0;
10625 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10626 wxString *arg2 = 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 bool temp2 = false ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "location", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10641 }
10642 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10643 {
10644 arg2 = wxString_in_helper(obj1);
10645 if (arg2 == NULL) SWIG_fail;
10646 temp2 = true;
10647 }
10648 {
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 {
10655 #if wxUSE_UNICODE
10656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10657 #else
10658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10659 #endif
10660 }
10661 {
10662 if (temp2)
10663 delete arg2;
10664 }
10665 return resultobj;
10666 fail:
10667 {
10668 if (temp2)
10669 delete arg2;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10678 wxString *arg2 = 0 ;
10679 wxString result;
10680 void *argp1 = 0 ;
10681 int res1 = 0 ;
10682 bool temp2 = false ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 char * kwnames[] = {
10686 (char *) "self",(char *) "location", NULL
10687 };
10688
10689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10693 }
10694 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10695 {
10696 arg2 = wxString_in_helper(obj1);
10697 if (arg2 == NULL) SWIG_fail;
10698 temp2 = true;
10699 }
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = (arg1)->GetAnchor((wxString const &)*arg2);
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 #if wxUSE_UNICODE
10708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10709 #else
10710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10711 #endif
10712 }
10713 {
10714 if (temp2)
10715 delete arg2;
10716 }
10717 return resultobj;
10718 fail:
10719 {
10720 if (temp2)
10721 delete arg2;
10722 }
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj = 0;
10729 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10730 wxString *arg2 = 0 ;
10731 wxString result;
10732 void *argp1 = 0 ;
10733 int res1 = 0 ;
10734 bool temp2 = false ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 char * kwnames[] = {
10738 (char *) "self",(char *) "location", NULL
10739 };
10740
10741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10747 {
10748 arg2 = wxString_in_helper(obj1);
10749 if (arg2 == NULL) SWIG_fail;
10750 temp2 = true;
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 {
10759 #if wxUSE_UNICODE
10760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10761 #else
10762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10763 #endif
10764 }
10765 {
10766 if (temp2)
10767 delete arg2;
10768 }
10769 return resultobj;
10770 fail:
10771 {
10772 if (temp2)
10773 delete arg2;
10774 }
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj = 0;
10781 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10782 wxString *arg2 = 0 ;
10783 wxString result;
10784 void *argp1 = 0 ;
10785 int res1 = 0 ;
10786 bool temp2 = false ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 char * kwnames[] = {
10790 (char *) "self",(char *) "location", NULL
10791 };
10792
10793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10795 if (!SWIG_IsOK(res1)) {
10796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10797 }
10798 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10799 {
10800 arg2 = wxString_in_helper(obj1);
10801 if (arg2 == NULL) SWIG_fail;
10802 temp2 = true;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 #if wxUSE_UNICODE
10812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10813 #else
10814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10815 #endif
10816 }
10817 {
10818 if (temp2)
10819 delete arg2;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 PyObject *obj;
10833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10834 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10835 return SWIG_Py_Void();
10836 }
10837
10838 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10839 return SWIG_Python_InitShadowInstance(args);
10840 }
10841
10842 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10843 PyObject *resultobj = 0;
10844 wxFileSystem *result = 0 ;
10845
10846 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (wxFileSystem *)new wxFileSystem();
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10863 PyObject *resultobj = 0;
10864 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 PyObject *swig_obj[1] ;
10868
10869 if (!args) SWIG_fail;
10870 swig_obj[0] = args;
10871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10874 }
10875 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 delete arg1;
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10893 wxString *arg2 = 0 ;
10894 bool arg3 = (bool) false ;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 bool temp2 = false ;
10898 bool val3 ;
10899 int ecode3 = 0 ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 PyObject * obj2 = 0 ;
10903 char * kwnames[] = {
10904 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10905 };
10906
10907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10909 if (!SWIG_IsOK(res1)) {
10910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10911 }
10912 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10913 {
10914 arg2 = wxString_in_helper(obj1);
10915 if (arg2 == NULL) SWIG_fail;
10916 temp2 = true;
10917 }
10918 if (obj2) {
10919 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10920 if (!SWIG_IsOK(ecode3)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10922 }
10923 arg3 = static_cast< bool >(val3);
10924 }
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_Py_Void();
10932 {
10933 if (temp2)
10934 delete arg2;
10935 }
10936 return resultobj;
10937 fail:
10938 {
10939 if (temp2)
10940 delete arg2;
10941 }
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *resultobj = 0;
10948 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10949 wxString result;
10950 void *argp1 = 0 ;
10951 int res1 = 0 ;
10952 PyObject *swig_obj[1] ;
10953
10954 if (!args) SWIG_fail;
10955 swig_obj[0] = args;
10956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10957 if (!SWIG_IsOK(res1)) {
10958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10959 }
10960 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10961 {
10962 PyThreadState* __tstate = wxPyBeginAllowThreads();
10963 result = (arg1)->GetPath();
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 #if wxUSE_UNICODE
10969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10970 #else
10971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10972 #endif
10973 }
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = 0;
10982 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10983 wxString *arg2 = 0 ;
10984 wxFSFile *result = 0 ;
10985 void *argp1 = 0 ;
10986 int res1 = 0 ;
10987 bool temp2 = false ;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 char * kwnames[] = {
10991 (char *) "self",(char *) "location", NULL
10992 };
10993
10994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10996 if (!SWIG_IsOK(res1)) {
10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10998 }
10999 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11000 {
11001 arg2 = wxString_in_helper(obj1);
11002 if (arg2 == NULL) SWIG_fail;
11003 temp2 = true;
11004 }
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11013 }
11014 {
11015 if (temp2)
11016 delete arg2;
11017 }
11018 return resultobj;
11019 fail:
11020 {
11021 if (temp2)
11022 delete arg2;
11023 }
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11031 wxString *arg2 = 0 ;
11032 int arg3 = (int) 0 ;
11033 wxString result;
11034 void *argp1 = 0 ;
11035 int res1 = 0 ;
11036 bool temp2 = false ;
11037 int val3 ;
11038 int ecode3 = 0 ;
11039 PyObject * obj0 = 0 ;
11040 PyObject * obj1 = 0 ;
11041 PyObject * obj2 = 0 ;
11042 char * kwnames[] = {
11043 (char *) "self",(char *) "spec",(char *) "flags", NULL
11044 };
11045
11046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11048 if (!SWIG_IsOK(res1)) {
11049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11050 }
11051 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11052 {
11053 arg2 = wxString_in_helper(obj1);
11054 if (arg2 == NULL) SWIG_fail;
11055 temp2 = true;
11056 }
11057 if (obj2) {
11058 ecode3 = SWIG_AsVal_int(obj2, &val3);
11059 if (!SWIG_IsOK(ecode3)) {
11060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11061 }
11062 arg3 = static_cast< int >(val3);
11063 }
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 #if wxUSE_UNICODE
11072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11073 #else
11074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11075 #endif
11076 }
11077 {
11078 if (temp2)
11079 delete arg2;
11080 }
11081 return resultobj;
11082 fail:
11083 {
11084 if (temp2)
11085 delete arg2;
11086 }
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 PyObject *resultobj = 0;
11093 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11094 wxString result;
11095 void *argp1 = 0 ;
11096 int res1 = 0 ;
11097 PyObject *swig_obj[1] ;
11098
11099 if (!args) SWIG_fail;
11100 swig_obj[0] = args;
11101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11102 if (!SWIG_IsOK(res1)) {
11103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11104 }
11105 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (arg1)->FindNext();
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 #if wxUSE_UNICODE
11114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11115 #else
11116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11117 #endif
11118 }
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj = 0;
11127 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11128 int res1 = 0 ;
11129 PyObject * obj0 = 0 ;
11130 char * kwnames[] = {
11131 (char *) "handler", NULL
11132 };
11133
11134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11135 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11136 if (!SWIG_IsOK(res1)) {
11137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11138 }
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 wxFileSystem::AddHandler(arg1);
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 resultobj = SWIG_Py_Void();
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = 0;
11154 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11155 wxFileSystemHandler *result = 0 ;
11156 void *argp1 = 0 ;
11157 int res1 = 0 ;
11158 PyObject * obj0 = 0 ;
11159 char * kwnames[] = {
11160 (char *) "handler", NULL
11161 };
11162
11163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11165 if (!SWIG_IsOK(res1)) {
11166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11167 }
11168 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11183 PyObject *resultobj = 0;
11184
11185 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 wxFileSystem::CleanUpHandlers();
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 resultobj = SWIG_Py_Void();
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11200 PyObject *resultobj = 0;
11201 wxString *arg1 = 0 ;
11202 wxString result;
11203 bool temp1 = false ;
11204 PyObject * obj0 = 0 ;
11205 char * kwnames[] = {
11206 (char *) "filename", NULL
11207 };
11208
11209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11210 {
11211 arg1 = wxString_in_helper(obj0);
11212 if (arg1 == NULL) SWIG_fail;
11213 temp1 = true;
11214 }
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 {
11222 #if wxUSE_UNICODE
11223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11224 #else
11225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11226 #endif
11227 }
11228 {
11229 if (temp1)
11230 delete arg1;
11231 }
11232 return resultobj;
11233 fail:
11234 {
11235 if (temp1)
11236 delete arg1;
11237 }
11238 return NULL;
11239 }
11240
11241
11242 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = 0;
11244 wxString *arg1 = 0 ;
11245 wxString result;
11246 bool temp1 = false ;
11247 PyObject * obj0 = 0 ;
11248 char * kwnames[] = {
11249 (char *) "url", NULL
11250 };
11251
11252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11253 {
11254 arg1 = wxString_in_helper(obj0);
11255 if (arg1 == NULL) SWIG_fail;
11256 temp1 = true;
11257 }
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 {
11265 #if wxUSE_UNICODE
11266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11267 #else
11268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11269 #endif
11270 }
11271 {
11272 if (temp1)
11273 delete arg1;
11274 }
11275 return resultobj;
11276 fail:
11277 {
11278 if (temp1)
11279 delete arg1;
11280 }
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11286 PyObject *obj;
11287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11288 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11289 return SWIG_Py_Void();
11290 }
11291
11292 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11293 return SWIG_Python_InitShadowInstance(args);
11294 }
11295
11296 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11297 PyObject *resultobj = 0;
11298 wxInternetFSHandler *result = 0 ;
11299
11300 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj = 0;
11316 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11317 wxString *arg2 = 0 ;
11318 bool result;
11319 void *argp1 = 0 ;
11320 int res1 = 0 ;
11321 bool temp2 = false ;
11322 PyObject * obj0 = 0 ;
11323 PyObject * obj1 = 0 ;
11324 char * kwnames[] = {
11325 (char *) "self",(char *) "location", NULL
11326 };
11327
11328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11330 if (!SWIG_IsOK(res1)) {
11331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11332 }
11333 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11334 {
11335 arg2 = wxString_in_helper(obj1);
11336 if (arg2 == NULL) SWIG_fail;
11337 temp2 = true;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 {
11346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11347 }
11348 {
11349 if (temp2)
11350 delete arg2;
11351 }
11352 return resultobj;
11353 fail:
11354 {
11355 if (temp2)
11356 delete arg2;
11357 }
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj = 0;
11364 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11365 wxFileSystem *arg2 = 0 ;
11366 wxString *arg3 = 0 ;
11367 wxFSFile *result = 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 void *argp2 = 0 ;
11371 int res2 = 0 ;
11372 bool temp3 = false ;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 char * kwnames[] = {
11377 (char *) "self",(char *) "fs",(char *) "location", NULL
11378 };
11379
11380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11384 }
11385 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11387 if (!SWIG_IsOK(res2)) {
11388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11389 }
11390 if (!argp2) {
11391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11392 }
11393 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11394 {
11395 arg3 = wxString_in_helper(obj2);
11396 if (arg3 == NULL) SWIG_fail;
11397 temp3 = true;
11398 }
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 {
11406 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11407 }
11408 {
11409 if (temp3)
11410 delete arg3;
11411 }
11412 return resultobj;
11413 fail:
11414 {
11415 if (temp3)
11416 delete arg3;
11417 }
11418 return NULL;
11419 }
11420
11421
11422 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423 PyObject *obj;
11424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11425 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11426 return SWIG_Py_Void();
11427 }
11428
11429 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11430 return SWIG_Python_InitShadowInstance(args);
11431 }
11432
11433 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434 PyObject *resultobj = 0;
11435 wxZipFSHandler *result = 0 ;
11436
11437 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (wxZipFSHandler *)new wxZipFSHandler();
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj = 0;
11453 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11454 wxString *arg2 = 0 ;
11455 bool result;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 bool temp2 = false ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char * kwnames[] = {
11462 (char *) "self",(char *) "location", NULL
11463 };
11464
11465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11467 if (!SWIG_IsOK(res1)) {
11468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11469 }
11470 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11471 {
11472 arg2 = wxString_in_helper(obj1);
11473 if (arg2 == NULL) SWIG_fail;
11474 temp2 = true;
11475 }
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11484 }
11485 {
11486 if (temp2)
11487 delete arg2;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp2)
11493 delete arg2;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj = 0;
11501 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11502 wxFileSystem *arg2 = 0 ;
11503 wxString *arg3 = 0 ;
11504 wxFSFile *result = 0 ;
11505 void *argp1 = 0 ;
11506 int res1 = 0 ;
11507 void *argp2 = 0 ;
11508 int res2 = 0 ;
11509 bool temp3 = false ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 PyObject * obj2 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "fs",(char *) "location", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11521 }
11522 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11524 if (!SWIG_IsOK(res2)) {
11525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11526 }
11527 if (!argp2) {
11528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11529 }
11530 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11531 {
11532 arg3 = wxString_in_helper(obj2);
11533 if (arg3 == NULL) SWIG_fail;
11534 temp3 = true;
11535 }
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11544 }
11545 {
11546 if (temp3)
11547 delete arg3;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp3)
11553 delete arg3;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = 0;
11561 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11562 wxString *arg2 = 0 ;
11563 int arg3 = (int) 0 ;
11564 wxString result;
11565 void *argp1 = 0 ;
11566 int res1 = 0 ;
11567 bool temp2 = false ;
11568 int val3 ;
11569 int ecode3 = 0 ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 char * kwnames[] = {
11574 (char *) "self",(char *) "spec",(char *) "flags", NULL
11575 };
11576
11577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11581 }
11582 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11583 {
11584 arg2 = wxString_in_helper(obj1);
11585 if (arg2 == NULL) SWIG_fail;
11586 temp2 = true;
11587 }
11588 if (obj2) {
11589 ecode3 = SWIG_AsVal_int(obj2, &val3);
11590 if (!SWIG_IsOK(ecode3)) {
11591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11592 }
11593 arg3 = static_cast< int >(val3);
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 {
11602 #if wxUSE_UNICODE
11603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11604 #else
11605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11606 #endif
11607 }
11608 {
11609 if (temp2)
11610 delete arg2;
11611 }
11612 return resultobj;
11613 fail:
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11625 wxString result;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11635 }
11636 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (arg1)->FindNext();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 {
11644 #if wxUSE_UNICODE
11645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11646 #else
11647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11648 #endif
11649 }
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 PyObject *obj;
11658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11659 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11660 return SWIG_Py_Void();
11661 }
11662
11663 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 return SWIG_Python_InitShadowInstance(args);
11665 }
11666
11667 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj = 0;
11669 wxString *arg1 = 0 ;
11670 wxImage *arg2 = 0 ;
11671 long arg3 ;
11672 bool temp1 = false ;
11673 void *argp2 = 0 ;
11674 int res2 = 0 ;
11675 long val3 ;
11676 int ecode3 = 0 ;
11677 PyObject * obj0 = 0 ;
11678 PyObject * obj1 = 0 ;
11679 PyObject * obj2 = 0 ;
11680 char * kwnames[] = {
11681 (char *) "filename",(char *) "image",(char *) "type", NULL
11682 };
11683
11684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11685 {
11686 arg1 = wxString_in_helper(obj0);
11687 if (arg1 == NULL) SWIG_fail;
11688 temp1 = true;
11689 }
11690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11691 if (!SWIG_IsOK(res2)) {
11692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11693 }
11694 if (!argp2) {
11695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11696 }
11697 arg2 = reinterpret_cast< wxImage * >(argp2);
11698 ecode3 = SWIG_AsVal_long(obj2, &val3);
11699 if (!SWIG_IsOK(ecode3)) {
11700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11701 }
11702 arg3 = static_cast< long >(val3);
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11706 wxPyEndAllowThreads(__tstate);
11707 if (PyErr_Occurred()) SWIG_fail;
11708 }
11709 resultobj = SWIG_Py_Void();
11710 {
11711 if (temp1)
11712 delete arg1;
11713 }
11714 return resultobj;
11715 fail:
11716 {
11717 if (temp1)
11718 delete arg1;
11719 }
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11725 PyObject *resultobj = 0;
11726 wxString *arg1 = 0 ;
11727 wxBitmap *arg2 = 0 ;
11728 long arg3 ;
11729 bool temp1 = false ;
11730 void *argp2 = 0 ;
11731 int res2 = 0 ;
11732 long val3 ;
11733 int ecode3 = 0 ;
11734 PyObject * obj0 = 0 ;
11735 PyObject * obj1 = 0 ;
11736 PyObject * obj2 = 0 ;
11737 char * kwnames[] = {
11738 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11739 };
11740
11741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11742 {
11743 arg1 = wxString_in_helper(obj0);
11744 if (arg1 == NULL) SWIG_fail;
11745 temp1 = true;
11746 }
11747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11748 if (!SWIG_IsOK(res2)) {
11749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11750 }
11751 if (!argp2) {
11752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11753 }
11754 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11755 ecode3 = SWIG_AsVal_long(obj2, &val3);
11756 if (!SWIG_IsOK(ecode3)) {
11757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11758 }
11759 arg3 = static_cast< long >(val3);
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 resultobj = SWIG_Py_Void();
11767 {
11768 if (temp1)
11769 delete arg1;
11770 }
11771 return resultobj;
11772 fail:
11773 {
11774 if (temp1)
11775 delete arg1;
11776 }
11777 return NULL;
11778 }
11779
11780
11781 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj = 0;
11783 wxString *arg1 = 0 ;
11784 PyObject *arg2 = (PyObject *) 0 ;
11785 bool temp1 = false ;
11786 PyObject * obj0 = 0 ;
11787 PyObject * obj1 = 0 ;
11788 char * kwnames[] = {
11789 (char *) "filename",(char *) "data", NULL
11790 };
11791
11792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11793 {
11794 arg1 = wxString_in_helper(obj0);
11795 if (arg1 == NULL) SWIG_fail;
11796 temp1 = true;
11797 }
11798 arg2 = obj1;
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 resultobj = SWIG_Py_Void();
11806 {
11807 if (temp1)
11808 delete arg1;
11809 }
11810 return resultobj;
11811 fail:
11812 {
11813 if (temp1)
11814 delete arg1;
11815 }
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821 PyObject *resultobj = 0;
11822 wxMemoryFSHandler *result = 0 ;
11823
11824 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj = 0;
11840 wxString *arg1 = 0 ;
11841 bool temp1 = false ;
11842 PyObject * obj0 = 0 ;
11843 char * kwnames[] = {
11844 (char *) "filename", NULL
11845 };
11846
11847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11848 {
11849 arg1 = wxString_in_helper(obj0);
11850 if (arg1 == NULL) SWIG_fail;
11851 temp1 = true;
11852 }
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 resultobj = SWIG_Py_Void();
11860 {
11861 if (temp1)
11862 delete arg1;
11863 }
11864 return resultobj;
11865 fail:
11866 {
11867 if (temp1)
11868 delete arg1;
11869 }
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj = 0;
11876 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11877 wxString *arg2 = 0 ;
11878 bool result;
11879 void *argp1 = 0 ;
11880 int res1 = 0 ;
11881 bool temp2 = false ;
11882 PyObject * obj0 = 0 ;
11883 PyObject * obj1 = 0 ;
11884 char * kwnames[] = {
11885 (char *) "self",(char *) "location", NULL
11886 };
11887
11888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11890 if (!SWIG_IsOK(res1)) {
11891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11892 }
11893 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11894 {
11895 arg2 = wxString_in_helper(obj1);
11896 if (arg2 == NULL) SWIG_fail;
11897 temp2 = true;
11898 }
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11902 wxPyEndAllowThreads(__tstate);
11903 if (PyErr_Occurred()) SWIG_fail;
11904 }
11905 {
11906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11907 }
11908 {
11909 if (temp2)
11910 delete arg2;
11911 }
11912 return resultobj;
11913 fail:
11914 {
11915 if (temp2)
11916 delete arg2;
11917 }
11918 return NULL;
11919 }
11920
11921
11922 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj = 0;
11924 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11925 wxFileSystem *arg2 = 0 ;
11926 wxString *arg3 = 0 ;
11927 wxFSFile *result = 0 ;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 void *argp2 = 0 ;
11931 int res2 = 0 ;
11932 bool temp3 = false ;
11933 PyObject * obj0 = 0 ;
11934 PyObject * obj1 = 0 ;
11935 PyObject * obj2 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "fs",(char *) "location", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11944 }
11945 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11946 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11947 if (!SWIG_IsOK(res2)) {
11948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11949 }
11950 if (!argp2) {
11951 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11952 }
11953 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11954 {
11955 arg3 = wxString_in_helper(obj2);
11956 if (arg3 == NULL) SWIG_fail;
11957 temp3 = true;
11958 }
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11967 }
11968 {
11969 if (temp3)
11970 delete arg3;
11971 }
11972 return resultobj;
11973 fail:
11974 {
11975 if (temp3)
11976 delete arg3;
11977 }
11978 return NULL;
11979 }
11980
11981
11982 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11983 PyObject *resultobj = 0;
11984 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11985 wxString *arg2 = 0 ;
11986 int arg3 = (int) 0 ;
11987 wxString result;
11988 void *argp1 = 0 ;
11989 int res1 = 0 ;
11990 bool temp2 = false ;
11991 int val3 ;
11992 int ecode3 = 0 ;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 PyObject * obj2 = 0 ;
11996 char * kwnames[] = {
11997 (char *) "self",(char *) "spec",(char *) "flags", NULL
11998 };
11999
12000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12002 if (!SWIG_IsOK(res1)) {
12003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12004 }
12005 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12006 {
12007 arg2 = wxString_in_helper(obj1);
12008 if (arg2 == NULL) SWIG_fail;
12009 temp2 = true;
12010 }
12011 if (obj2) {
12012 ecode3 = SWIG_AsVal_int(obj2, &val3);
12013 if (!SWIG_IsOK(ecode3)) {
12014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12015 }
12016 arg3 = static_cast< int >(val3);
12017 }
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12021 wxPyEndAllowThreads(__tstate);
12022 if (PyErr_Occurred()) SWIG_fail;
12023 }
12024 {
12025 #if wxUSE_UNICODE
12026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12027 #else
12028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12029 #endif
12030 }
12031 {
12032 if (temp2)
12033 delete arg2;
12034 }
12035 return resultobj;
12036 fail:
12037 {
12038 if (temp2)
12039 delete arg2;
12040 }
12041 return NULL;
12042 }
12043
12044
12045 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12046 PyObject *resultobj = 0;
12047 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12048 wxString result;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12058 }
12059 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (arg1)->FindNext();
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 {
12067 #if wxUSE_UNICODE
12068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12069 #else
12070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12071 #endif
12072 }
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 PyObject *obj;
12081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12082 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12083 return SWIG_Py_Void();
12084 }
12085
12086 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 return SWIG_Python_InitShadowInstance(args);
12088 }
12089
12090 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *resultobj = 0;
12092 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12093 wxString result;
12094 void *argp1 = 0 ;
12095 int res1 = 0 ;
12096 PyObject *swig_obj[1] ;
12097
12098 if (!args) SWIG_fail;
12099 swig_obj[0] = args;
12100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12101 if (!SWIG_IsOK(res1)) {
12102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12103 }
12104 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (arg1)->GetName();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 {
12112 #if wxUSE_UNICODE
12113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12114 #else
12115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12116 #endif
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12125 PyObject *resultobj = 0;
12126 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12127 wxString result;
12128 void *argp1 = 0 ;
12129 int res1 = 0 ;
12130 PyObject *swig_obj[1] ;
12131
12132 if (!args) SWIG_fail;
12133 swig_obj[0] = args;
12134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12135 if (!SWIG_IsOK(res1)) {
12136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12137 }
12138 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (arg1)->GetExtension();
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 #if wxUSE_UNICODE
12147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12148 #else
12149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12150 #endif
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 PyObject *resultobj = 0;
12160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12161 long result;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 PyObject *swig_obj[1] ;
12165
12166 if (!args) SWIG_fail;
12167 swig_obj[0] = args;
12168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12171 }
12172 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (long)(arg1)->GetType();
12176 wxPyEndAllowThreads(__tstate);
12177 if (PyErr_Occurred()) SWIG_fail;
12178 }
12179 resultobj = SWIG_From_long(static_cast< long >(result));
12180 return resultobj;
12181 fail:
12182 return NULL;
12183 }
12184
12185
12186 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12187 PyObject *resultobj = 0;
12188 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12189 wxString result;
12190 void *argp1 = 0 ;
12191 int res1 = 0 ;
12192 PyObject *swig_obj[1] ;
12193
12194 if (!args) SWIG_fail;
12195 swig_obj[0] = args;
12196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12197 if (!SWIG_IsOK(res1)) {
12198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12199 }
12200 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (arg1)->GetMimeType();
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 {
12208 #if wxUSE_UNICODE
12209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12210 #else
12211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12212 #endif
12213 }
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12221 PyObject *resultobj = 0;
12222 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12223 wxString *arg2 = 0 ;
12224 bool result;
12225 void *argp1 = 0 ;
12226 int res1 = 0 ;
12227 bool temp2 = false ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 char * kwnames[] = {
12231 (char *) "self",(char *) "name", NULL
12232 };
12233
12234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12236 if (!SWIG_IsOK(res1)) {
12237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12238 }
12239 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12240 {
12241 arg2 = wxString_in_helper(obj1);
12242 if (arg2 == NULL) SWIG_fail;
12243 temp2 = true;
12244 }
12245 {
12246 PyThreadState* __tstate = wxPyBeginAllowThreads();
12247 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12248 wxPyEndAllowThreads(__tstate);
12249 if (PyErr_Occurred()) SWIG_fail;
12250 }
12251 {
12252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12253 }
12254 {
12255 if (temp2)
12256 delete arg2;
12257 }
12258 return resultobj;
12259 fail:
12260 {
12261 if (temp2)
12262 delete arg2;
12263 }
12264 return NULL;
12265 }
12266
12267
12268 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12269 PyObject *resultobj = 0;
12270 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12271 wxInputStream *arg2 = 0 ;
12272 bool result;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 wxPyInputStream *temp2 ;
12276 bool created2 ;
12277 PyObject * obj0 = 0 ;
12278 PyObject * obj1 = 0 ;
12279 char * kwnames[] = {
12280 (char *) "self",(char *) "stream", NULL
12281 };
12282
12283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12285 if (!SWIG_IsOK(res1)) {
12286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12287 }
12288 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12289 {
12290 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12291 arg2 = temp2->m_wxis;
12292 created2 = false;
12293 } else {
12294 PyErr_Clear(); // clear the failure of the wxPyConvert above
12295 arg2 = wxPyCBInputStream_create(obj1, false);
12296 if (arg2 == NULL) {
12297 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12298 SWIG_fail;
12299 }
12300 created2 = true;
12301 }
12302 }
12303 {
12304 PyThreadState* __tstate = wxPyBeginAllowThreads();
12305 result = (bool)(arg1)->CanRead(*arg2);
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12311 }
12312 {
12313 if (created2) delete arg2;
12314 }
12315 return resultobj;
12316 fail:
12317 {
12318 if (created2) delete arg2;
12319 }
12320 return NULL;
12321 }
12322
12323
12324 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj = 0;
12326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12327 wxString *arg2 = 0 ;
12328 void *argp1 = 0 ;
12329 int res1 = 0 ;
12330 bool temp2 = false ;
12331 PyObject * obj0 = 0 ;
12332 PyObject * obj1 = 0 ;
12333 char * kwnames[] = {
12334 (char *) "self",(char *) "name", NULL
12335 };
12336
12337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12341 }
12342 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12343 {
12344 arg2 = wxString_in_helper(obj1);
12345 if (arg2 == NULL) SWIG_fail;
12346 temp2 = true;
12347 }
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 (arg1)->SetName((wxString const &)*arg2);
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 resultobj = SWIG_Py_Void();
12355 {
12356 if (temp2)
12357 delete arg2;
12358 }
12359 return resultobj;
12360 fail:
12361 {
12362 if (temp2)
12363 delete arg2;
12364 }
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj = 0;
12371 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12372 wxString *arg2 = 0 ;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 bool temp2 = false ;
12376 PyObject * obj0 = 0 ;
12377 PyObject * obj1 = 0 ;
12378 char * kwnames[] = {
12379 (char *) "self",(char *) "extension", NULL
12380 };
12381
12382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12386 }
12387 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12388 {
12389 arg2 = wxString_in_helper(obj1);
12390 if (arg2 == NULL) SWIG_fail;
12391 temp2 = true;
12392 }
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 (arg1)->SetExtension((wxString const &)*arg2);
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 resultobj = SWIG_Py_Void();
12400 {
12401 if (temp2)
12402 delete arg2;
12403 }
12404 return resultobj;
12405 fail:
12406 {
12407 if (temp2)
12408 delete arg2;
12409 }
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12417 long arg2 ;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 long val2 ;
12421 int ecode2 = 0 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "self",(char *) "type", NULL
12426 };
12427
12428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12432 }
12433 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12434 ecode2 = SWIG_AsVal_long(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12437 }
12438 arg2 = static_cast< long >(val2);
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 (arg1)->SetType(arg2);
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 resultobj = SWIG_Py_Void();
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj = 0;
12454 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12455 wxString *arg2 = 0 ;
12456 void *argp1 = 0 ;
12457 int res1 = 0 ;
12458 bool temp2 = false ;
12459 PyObject * obj0 = 0 ;
12460 PyObject * obj1 = 0 ;
12461 char * kwnames[] = {
12462 (char *) "self",(char *) "mimetype", NULL
12463 };
12464
12465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12467 if (!SWIG_IsOK(res1)) {
12468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12469 }
12470 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12471 {
12472 arg2 = wxString_in_helper(obj1);
12473 if (arg2 == NULL) SWIG_fail;
12474 temp2 = true;
12475 }
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 (arg1)->SetMimeType((wxString const &)*arg2);
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 resultobj = SWIG_Py_Void();
12483 {
12484 if (temp2)
12485 delete arg2;
12486 }
12487 return resultobj;
12488 fail:
12489 {
12490 if (temp2)
12491 delete arg2;
12492 }
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12498 PyObject *obj;
12499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12500 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12501 return SWIG_Py_Void();
12502 }
12503
12504 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12505 PyObject *resultobj = 0;
12506 wxPyImageHandler *result = 0 ;
12507
12508 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (wxPyImageHandler *)new wxPyImageHandler();
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12525 PyObject *arg2 = (PyObject *) 0 ;
12526 void *argp1 = 0 ;
12527 int res1 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "self", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12538 }
12539 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12540 arg2 = obj1;
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 (arg1)->_SetSelf(arg2);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *obj;
12556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12557 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12558 return SWIG_Py_Void();
12559 }
12560
12561 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12562 return SWIG_Python_InitShadowInstance(args);
12563 }
12564
12565 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *resultobj = 0;
12567 wxImageHistogram *result = 0 ;
12568
12569 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 result = (wxImageHistogram *)new wxImageHistogram();
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 byte arg1 ;
12586 byte arg2 ;
12587 byte arg3 ;
12588 unsigned long result;
12589 unsigned char val1 ;
12590 int ecode1 = 0 ;
12591 unsigned char val2 ;
12592 int ecode2 = 0 ;
12593 unsigned char val3 ;
12594 int ecode3 = 0 ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "r",(char *) "g",(char *) "b", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12603 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12604 if (!SWIG_IsOK(ecode1)) {
12605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12606 }
12607 arg1 = static_cast< byte >(val1);
12608 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12609 if (!SWIG_IsOK(ecode2)) {
12610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12611 }
12612 arg2 = static_cast< byte >(val2);
12613 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12614 if (!SWIG_IsOK(ecode3)) {
12615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12616 }
12617 arg3 = static_cast< byte >(val3);
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12634 byte *arg2 = (byte *) 0 ;
12635 byte *arg3 = (byte *) 0 ;
12636 byte *arg4 = (byte *) 0 ;
12637 byte arg5 = (byte) 1 ;
12638 byte arg6 = (byte) 0 ;
12639 byte arg7 = (byte) 0 ;
12640 bool result;
12641 void *argp1 = 0 ;
12642 int res1 = 0 ;
12643 byte temp2 ;
12644 int res2 = SWIG_TMPOBJ ;
12645 byte temp3 ;
12646 int res3 = SWIG_TMPOBJ ;
12647 byte temp4 ;
12648 int res4 = SWIG_TMPOBJ ;
12649 unsigned char val5 ;
12650 int ecode5 = 0 ;
12651 unsigned char val6 ;
12652 int ecode6 = 0 ;
12653 unsigned char val7 ;
12654 int ecode7 = 0 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 PyObject * obj3 = 0 ;
12659 char * kwnames[] = {
12660 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12661 };
12662
12663 arg2 = &temp2;
12664 arg3 = &temp3;
12665 arg4 = &temp4;
12666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12668 if (!SWIG_IsOK(res1)) {
12669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12670 }
12671 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12672 if (obj1) {
12673 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12674 if (!SWIG_IsOK(ecode5)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12676 }
12677 arg5 = static_cast< byte >(val5);
12678 }
12679 if (obj2) {
12680 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12681 if (!SWIG_IsOK(ecode6)) {
12682 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12683 }
12684 arg6 = static_cast< byte >(val6);
12685 }
12686 if (obj3) {
12687 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12688 if (!SWIG_IsOK(ecode7)) {
12689 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12690 }
12691 arg7 = static_cast< byte >(val7);
12692 }
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 {
12700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12701 }
12702 if (SWIG_IsTmpObj(res2)) {
12703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12704 } else {
12705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12707 }
12708 if (SWIG_IsTmpObj(res3)) {
12709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12710 } else {
12711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12713 }
12714 if (SWIG_IsTmpObj(res4)) {
12715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12716 } else {
12717 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12719 }
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj = 0;
12728 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12729 unsigned long arg2 ;
12730 unsigned long result;
12731 void *argp1 = 0 ;
12732 int res1 = 0 ;
12733 unsigned long val2 ;
12734 int ecode2 = 0 ;
12735 PyObject * obj0 = 0 ;
12736 PyObject * obj1 = 0 ;
12737 char * kwnames[] = {
12738 (char *) "self",(char *) "key", NULL
12739 };
12740
12741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12743 if (!SWIG_IsOK(res1)) {
12744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12745 }
12746 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12747 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12748 if (!SWIG_IsOK(ecode2)) {
12749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12750 }
12751 arg2 = static_cast< unsigned long >(val2);
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12755 wxPyEndAllowThreads(__tstate);
12756 if (PyErr_Occurred()) SWIG_fail;
12757 }
12758 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj = 0;
12767 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12768 byte arg2 ;
12769 byte arg3 ;
12770 byte arg4 ;
12771 unsigned long result;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 unsigned char val2 ;
12775 int ecode2 = 0 ;
12776 unsigned char val3 ;
12777 int ecode3 = 0 ;
12778 unsigned char val4 ;
12779 int ecode4 = 0 ;
12780 PyObject * obj0 = 0 ;
12781 PyObject * obj1 = 0 ;
12782 PyObject * obj2 = 0 ;
12783 PyObject * obj3 = 0 ;
12784 char * kwnames[] = {
12785 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12786 };
12787
12788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12792 }
12793 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12794 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12795 if (!SWIG_IsOK(ecode2)) {
12796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12797 }
12798 arg2 = static_cast< byte >(val2);
12799 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12800 if (!SWIG_IsOK(ecode3)) {
12801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12802 }
12803 arg3 = static_cast< byte >(val3);
12804 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12805 if (!SWIG_IsOK(ecode4)) {
12806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12807 }
12808 arg4 = static_cast< byte >(val4);
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12825 wxColour *arg2 = 0 ;
12826 unsigned long result;
12827 void *argp1 = 0 ;
12828 int res1 = 0 ;
12829 wxColour temp2 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 char * kwnames[] = {
12833 (char *) "self",(char *) "colour", NULL
12834 };
12835
12836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12840 }
12841 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12842 {
12843 arg2 = &temp2;
12844 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12845 }
12846 {
12847 PyThreadState* __tstate = wxPyBeginAllowThreads();
12848 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12860 PyObject *obj;
12861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12862 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12863 return SWIG_Py_Void();
12864 }
12865
12866 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12867 return SWIG_Python_InitShadowInstance(args);
12868 }
12869
12870 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj = 0;
12872 byte arg1 = (byte) 0 ;
12873 byte arg2 = (byte) 0 ;
12874 byte arg3 = (byte) 0 ;
12875 wxImage_RGBValue *result = 0 ;
12876 unsigned char val1 ;
12877 int ecode1 = 0 ;
12878 unsigned char val2 ;
12879 int ecode2 = 0 ;
12880 unsigned char val3 ;
12881 int ecode3 = 0 ;
12882 PyObject * obj0 = 0 ;
12883 PyObject * obj1 = 0 ;
12884 PyObject * obj2 = 0 ;
12885 char * kwnames[] = {
12886 (char *) "r",(char *) "g",(char *) "b", NULL
12887 };
12888
12889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12890 if (obj0) {
12891 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12892 if (!SWIG_IsOK(ecode1)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12894 }
12895 arg1 = static_cast< byte >(val1);
12896 }
12897 if (obj1) {
12898 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12899 if (!SWIG_IsOK(ecode2)) {
12900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12901 }
12902 arg2 = static_cast< byte >(val2);
12903 }
12904 if (obj2) {
12905 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12906 if (!SWIG_IsOK(ecode3)) {
12907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12908 }
12909 arg3 = static_cast< byte >(val3);
12910 }
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 PyObject *resultobj = 0;
12926 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12927 byte arg2 ;
12928 void *argp1 = 0 ;
12929 int res1 = 0 ;
12930 unsigned char val2 ;
12931 int ecode2 = 0 ;
12932 PyObject *swig_obj[2] ;
12933
12934 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12936 if (!SWIG_IsOK(res1)) {
12937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12938 }
12939 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12940 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12941 if (!SWIG_IsOK(ecode2)) {
12942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12943 }
12944 arg2 = static_cast< byte >(val2);
12945 if (arg1) (arg1)->red = arg2;
12946
12947 resultobj = SWIG_Py_Void();
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12955 PyObject *resultobj = 0;
12956 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12957 byte result;
12958 void *argp1 = 0 ;
12959 int res1 = 0 ;
12960 PyObject *swig_obj[1] ;
12961
12962 if (!args) SWIG_fail;
12963 swig_obj[0] = args;
12964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12967 }
12968 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12969 result = (byte) ((arg1)->red);
12970 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12971 return resultobj;
12972 fail:
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12980 byte arg2 ;
12981 void *argp1 = 0 ;
12982 int res1 = 0 ;
12983 unsigned char val2 ;
12984 int ecode2 = 0 ;
12985 PyObject *swig_obj[2] ;
12986
12987 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12989 if (!SWIG_IsOK(res1)) {
12990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12991 }
12992 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12993 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12994 if (!SWIG_IsOK(ecode2)) {
12995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12996 }
12997 arg2 = static_cast< byte >(val2);
12998 if (arg1) (arg1)->green = arg2;
12999
13000 resultobj = SWIG_Py_Void();
13001 return resultobj;
13002 fail:
13003 return NULL;
13004 }
13005
13006
13007 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 PyObject *resultobj = 0;
13009 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13010 byte result;
13011 void *argp1 = 0 ;
13012 int res1 = 0 ;
13013 PyObject *swig_obj[1] ;
13014
13015 if (!args) SWIG_fail;
13016 swig_obj[0] = args;
13017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13018 if (!SWIG_IsOK(res1)) {
13019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13020 }
13021 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13022 result = (byte) ((arg1)->green);
13023 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13033 byte arg2 ;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 unsigned char val2 ;
13037 int ecode2 = 0 ;
13038 PyObject *swig_obj[2] ;
13039
13040 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13044 }
13045 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13046 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13047 if (!SWIG_IsOK(ecode2)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13049 }
13050 arg2 = static_cast< byte >(val2);
13051 if (arg1) (arg1)->blue = arg2;
13052
13053 resultobj = SWIG_Py_Void();
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13063 byte result;
13064 void *argp1 = 0 ;
13065 int res1 = 0 ;
13066 PyObject *swig_obj[1] ;
13067
13068 if (!args) SWIG_fail;
13069 swig_obj[0] = args;
13070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13071 if (!SWIG_IsOK(res1)) {
13072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13073 }
13074 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13075 result = (byte) ((arg1)->blue);
13076 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *obj;
13085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13086 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13087 return SWIG_Py_Void();
13088 }
13089
13090 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13091 return SWIG_Python_InitShadowInstance(args);
13092 }
13093
13094 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13095 PyObject *resultobj = 0;
13096 double arg1 = (double) 0.0 ;
13097 double arg2 = (double) 0.0 ;
13098 double arg3 = (double) 0.0 ;
13099 wxImage_HSVValue *result = 0 ;
13100 double val1 ;
13101 int ecode1 = 0 ;
13102 double val2 ;
13103 int ecode2 = 0 ;
13104 double val3 ;
13105 int ecode3 = 0 ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 char * kwnames[] = {
13110 (char *) "h",(char *) "s",(char *) "v", NULL
13111 };
13112
13113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13114 if (obj0) {
13115 ecode1 = SWIG_AsVal_double(obj0, &val1);
13116 if (!SWIG_IsOK(ecode1)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13118 }
13119 arg1 = static_cast< double >(val1);
13120 }
13121 if (obj1) {
13122 ecode2 = SWIG_AsVal_double(obj1, &val2);
13123 if (!SWIG_IsOK(ecode2)) {
13124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13125 }
13126 arg2 = static_cast< double >(val2);
13127 }
13128 if (obj2) {
13129 ecode3 = SWIG_AsVal_double(obj2, &val3);
13130 if (!SWIG_IsOK(ecode3)) {
13131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13132 }
13133 arg3 = static_cast< double >(val3);
13134 }
13135 {
13136 PyThreadState* __tstate = wxPyBeginAllowThreads();
13137 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13149 PyObject *resultobj = 0;
13150 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13151 double arg2 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 double val2 ;
13155 int ecode2 = 0 ;
13156 PyObject *swig_obj[2] ;
13157
13158 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13162 }
13163 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13164 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13165 if (!SWIG_IsOK(ecode2)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13167 }
13168 arg2 = static_cast< double >(val2);
13169 if (arg1) (arg1)->hue = arg2;
13170
13171 resultobj = SWIG_Py_Void();
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13179 PyObject *resultobj = 0;
13180 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13181 double result;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 PyObject *swig_obj[1] ;
13185
13186 if (!args) SWIG_fail;
13187 swig_obj[0] = args;
13188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13189 if (!SWIG_IsOK(res1)) {
13190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13191 }
13192 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13193 result = (double) ((arg1)->hue);
13194 resultobj = SWIG_From_double(static_cast< double >(result));
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13202 PyObject *resultobj = 0;
13203 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13204 double arg2 ;
13205 void *argp1 = 0 ;
13206 int res1 = 0 ;
13207 double val2 ;
13208 int ecode2 = 0 ;
13209 PyObject *swig_obj[2] ;
13210
13211 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13213 if (!SWIG_IsOK(res1)) {
13214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13215 }
13216 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13218 if (!SWIG_IsOK(ecode2)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13220 }
13221 arg2 = static_cast< double >(val2);
13222 if (arg1) (arg1)->saturation = arg2;
13223
13224 resultobj = SWIG_Py_Void();
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 PyObject *resultobj = 0;
13233 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13234 double result;
13235 void *argp1 = 0 ;
13236 int res1 = 0 ;
13237 PyObject *swig_obj[1] ;
13238
13239 if (!args) SWIG_fail;
13240 swig_obj[0] = args;
13241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13242 if (!SWIG_IsOK(res1)) {
13243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13244 }
13245 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13246 result = (double) ((arg1)->saturation);
13247 resultobj = SWIG_From_double(static_cast< double >(result));
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13255 PyObject *resultobj = 0;
13256 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13257 double arg2 ;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 double val2 ;
13261 int ecode2 = 0 ;
13262 PyObject *swig_obj[2] ;
13263
13264 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13266 if (!SWIG_IsOK(res1)) {
13267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13268 }
13269 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13271 if (!SWIG_IsOK(ecode2)) {
13272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13273 }
13274 arg2 = static_cast< double >(val2);
13275 if (arg1) (arg1)->value = arg2;
13276
13277 resultobj = SWIG_Py_Void();
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13285 PyObject *resultobj = 0;
13286 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13287 double result;
13288 void *argp1 = 0 ;
13289 int res1 = 0 ;
13290 PyObject *swig_obj[1] ;
13291
13292 if (!args) SWIG_fail;
13293 swig_obj[0] = args;
13294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13295 if (!SWIG_IsOK(res1)) {
13296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13297 }
13298 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13299 result = (double) ((arg1)->value);
13300 resultobj = SWIG_From_double(static_cast< double >(result));
13301 return resultobj;
13302 fail:
13303 return NULL;
13304 }
13305
13306
13307 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13308 PyObject *obj;
13309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13310 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13311 return SWIG_Py_Void();
13312 }
13313
13314 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 return SWIG_Python_InitShadowInstance(args);
13316 }
13317
13318 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj = 0;
13320 wxString *arg1 = 0 ;
13321 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13322 int arg3 = (int) -1 ;
13323 wxImage *result = 0 ;
13324 bool temp1 = false ;
13325 long val2 ;
13326 int ecode2 = 0 ;
13327 int val3 ;
13328 int ecode3 = 0 ;
13329 PyObject * obj0 = 0 ;
13330 PyObject * obj1 = 0 ;
13331 PyObject * obj2 = 0 ;
13332 char * kwnames[] = {
13333 (char *) "name",(char *) "type",(char *) "index", NULL
13334 };
13335
13336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13337 {
13338 arg1 = wxString_in_helper(obj0);
13339 if (arg1 == NULL) SWIG_fail;
13340 temp1 = true;
13341 }
13342 if (obj1) {
13343 ecode2 = SWIG_AsVal_long(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13346 }
13347 arg2 = static_cast< long >(val2);
13348 }
13349 if (obj2) {
13350 ecode3 = SWIG_AsVal_int(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13353 }
13354 arg3 = static_cast< int >(val3);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13363 {
13364 if (temp1)
13365 delete arg1;
13366 }
13367 return resultobj;
13368 fail:
13369 {
13370 if (temp1)
13371 delete arg1;
13372 }
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 void *argp1 = 0 ;
13381 int res1 = 0 ;
13382 PyObject *swig_obj[1] ;
13383
13384 if (!args) SWIG_fail;
13385 swig_obj[0] = args;
13386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13389 }
13390 arg1 = reinterpret_cast< wxImage * >(argp1);
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 delete arg1;
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_Py_Void();
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj = 0;
13407 wxString *arg1 = 0 ;
13408 wxString *arg2 = 0 ;
13409 int arg3 = (int) -1 ;
13410 wxImage *result = 0 ;
13411 bool temp1 = false ;
13412 bool temp2 = false ;
13413 int val3 ;
13414 int ecode3 = 0 ;
13415 PyObject * obj0 = 0 ;
13416 PyObject * obj1 = 0 ;
13417 PyObject * obj2 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13423 {
13424 arg1 = wxString_in_helper(obj0);
13425 if (arg1 == NULL) SWIG_fail;
13426 temp1 = true;
13427 }
13428 {
13429 arg2 = wxString_in_helper(obj1);
13430 if (arg2 == NULL) SWIG_fail;
13431 temp2 = true;
13432 }
13433 if (obj2) {
13434 ecode3 = SWIG_AsVal_int(obj2, &val3);
13435 if (!SWIG_IsOK(ecode3)) {
13436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13437 }
13438 arg3 = static_cast< int >(val3);
13439 }
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13447 {
13448 if (temp1)
13449 delete arg1;
13450 }
13451 {
13452 if (temp2)
13453 delete arg2;
13454 }
13455 return resultobj;
13456 fail:
13457 {
13458 if (temp1)
13459 delete arg1;
13460 }
13461 {
13462 if (temp2)
13463 delete arg2;
13464 }
13465 return NULL;
13466 }
13467
13468
13469 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13470 PyObject *resultobj = 0;
13471 wxInputStream *arg1 = 0 ;
13472 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13473 int arg3 = (int) -1 ;
13474 wxImage *result = 0 ;
13475 wxPyInputStream *temp1 ;
13476 bool created1 ;
13477 long val2 ;
13478 int ecode2 = 0 ;
13479 int val3 ;
13480 int ecode3 = 0 ;
13481 PyObject * obj0 = 0 ;
13482 PyObject * obj1 = 0 ;
13483 PyObject * obj2 = 0 ;
13484 char * kwnames[] = {
13485 (char *) "stream",(char *) "type",(char *) "index", NULL
13486 };
13487
13488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13489 {
13490 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13491 arg1 = temp1->m_wxis;
13492 created1 = false;
13493 } else {
13494 PyErr_Clear(); // clear the failure of the wxPyConvert above
13495 arg1 = wxPyCBInputStream_create(obj0, false);
13496 if (arg1 == NULL) {
13497 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13498 SWIG_fail;
13499 }
13500 created1 = true;
13501 }
13502 }
13503 if (obj1) {
13504 ecode2 = SWIG_AsVal_long(obj1, &val2);
13505 if (!SWIG_IsOK(ecode2)) {
13506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13507 }
13508 arg2 = static_cast< long >(val2);
13509 }
13510 if (obj2) {
13511 ecode3 = SWIG_AsVal_int(obj2, &val3);
13512 if (!SWIG_IsOK(ecode3)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13514 }
13515 arg3 = static_cast< int >(val3);
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13524 {
13525 if (created1) delete arg1;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (created1) delete arg1;
13531 }
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13537 PyObject *resultobj = 0;
13538 wxInputStream *arg1 = 0 ;
13539 wxString *arg2 = 0 ;
13540 int arg3 = (int) -1 ;
13541 wxImage *result = 0 ;
13542 wxPyInputStream *temp1 ;
13543 bool created1 ;
13544 bool temp2 = false ;
13545 int val3 ;
13546 int ecode3 = 0 ;
13547 PyObject * obj0 = 0 ;
13548 PyObject * obj1 = 0 ;
13549 PyObject * obj2 = 0 ;
13550 char * kwnames[] = {
13551 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13552 };
13553
13554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13555 {
13556 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13557 arg1 = temp1->m_wxis;
13558 created1 = false;
13559 } else {
13560 PyErr_Clear(); // clear the failure of the wxPyConvert above
13561 arg1 = wxPyCBInputStream_create(obj0, false);
13562 if (arg1 == NULL) {
13563 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13564 SWIG_fail;
13565 }
13566 created1 = true;
13567 }
13568 }
13569 {
13570 arg2 = wxString_in_helper(obj1);
13571 if (arg2 == NULL) SWIG_fail;
13572 temp2 = true;
13573 }
13574 if (obj2) {
13575 ecode3 = SWIG_AsVal_int(obj2, &val3);
13576 if (!SWIG_IsOK(ecode3)) {
13577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13578 }
13579 arg3 = static_cast< int >(val3);
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13588 {
13589 if (created1) delete arg1;
13590 }
13591 {
13592 if (temp2)
13593 delete arg2;
13594 }
13595 return resultobj;
13596 fail:
13597 {
13598 if (created1) delete arg1;
13599 }
13600 {
13601 if (temp2)
13602 delete arg2;
13603 }
13604 return NULL;
13605 }
13606
13607
13608 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13609 PyObject *resultobj = 0;
13610 int arg1 = (int) 0 ;
13611 int arg2 = (int) 0 ;
13612 bool arg3 = (bool) true ;
13613 wxImage *result = 0 ;
13614 int val1 ;
13615 int ecode1 = 0 ;
13616 int val2 ;
13617 int ecode2 = 0 ;
13618 bool val3 ;
13619 int ecode3 = 0 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 PyObject * obj2 = 0 ;
13623 char * kwnames[] = {
13624 (char *) "width",(char *) "height",(char *) "clear", NULL
13625 };
13626
13627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13628 if (obj0) {
13629 ecode1 = SWIG_AsVal_int(obj0, &val1);
13630 if (!SWIG_IsOK(ecode1)) {
13631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13632 }
13633 arg1 = static_cast< int >(val1);
13634 }
13635 if (obj1) {
13636 ecode2 = SWIG_AsVal_int(obj1, &val2);
13637 if (!SWIG_IsOK(ecode2)) {
13638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13639 }
13640 arg2 = static_cast< int >(val2);
13641 }
13642 if (obj2) {
13643 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13644 if (!SWIG_IsOK(ecode3)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13646 }
13647 arg3 = static_cast< bool >(val3);
13648 }
13649 {
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj = 0;
13664 wxBitmap *arg1 = 0 ;
13665 wxImage *result = 0 ;
13666 void *argp1 = 0 ;
13667 int res1 = 0 ;
13668 PyObject * obj0 = 0 ;
13669 char * kwnames[] = {
13670 (char *) "bitmap", NULL
13671 };
13672
13673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13674 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13675 if (!SWIG_IsOK(res1)) {
13676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13677 }
13678 if (!argp1) {
13679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13680 }
13681 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13682 {
13683 if (!wxPyCheckForApp()) SWIG_fail;
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13690 return resultobj;
13691 fail:
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 int arg1 ;
13699 int arg2 ;
13700 buffer arg3 ;
13701 int arg4 ;
13702 wxImage *result = 0 ;
13703 int val1 ;
13704 int ecode1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 Py_ssize_t temp3 ;
13708 PyObject * obj0 = 0 ;
13709 PyObject * obj1 = 0 ;
13710 PyObject * obj2 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "width",(char *) "height",(char *) "data", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13716 ecode1 = SWIG_AsVal_int(obj0, &val1);
13717 if (!SWIG_IsOK(ecode1)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13719 }
13720 arg1 = static_cast< int >(val1);
13721 ecode2 = SWIG_AsVal_int(obj1, &val2);
13722 if (!SWIG_IsOK(ecode2)) {
13723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13724 }
13725 arg2 = static_cast< int >(val2);
13726 {
13727 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13728 arg4 = (int)temp3;
13729 }
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13733 wxPyEndAllowThreads(__tstate);
13734 if (PyErr_Occurred()) SWIG_fail;
13735 }
13736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13737 return resultobj;
13738 fail:
13739 return NULL;
13740 }
13741
13742
13743 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13744 PyObject *resultobj = 0;
13745 int arg1 ;
13746 int arg2 ;
13747 buffer arg3 ;
13748 int arg4 ;
13749 buffer arg5 ;
13750 int arg6 ;
13751 wxImage *result = 0 ;
13752 int val1 ;
13753 int ecode1 = 0 ;
13754 int val2 ;
13755 int ecode2 = 0 ;
13756 Py_ssize_t temp3 ;
13757 Py_ssize_t temp5 ;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 PyObject * obj3 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13767 ecode1 = SWIG_AsVal_int(obj0, &val1);
13768 if (!SWIG_IsOK(ecode1)) {
13769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13770 }
13771 arg1 = static_cast< int >(val1);
13772 ecode2 = SWIG_AsVal_int(obj1, &val2);
13773 if (!SWIG_IsOK(ecode2)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13775 }
13776 arg2 = static_cast< int >(val2);
13777 {
13778 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13779 arg4 = (int)temp3;
13780 }
13781 {
13782 if (obj3 != Py_None) {
13783 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13784 arg6 = (int)temp5;
13785 }
13786 }
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj = 0;
13802 wxImage *arg1 = (wxImage *) 0 ;
13803 int arg2 ;
13804 int arg3 ;
13805 bool arg4 = (bool) true ;
13806 void *argp1 = 0 ;
13807 int res1 = 0 ;
13808 int val2 ;
13809 int ecode2 = 0 ;
13810 int val3 ;
13811 int ecode3 = 0 ;
13812 bool val4 ;
13813 int ecode4 = 0 ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 PyObject * obj2 = 0 ;
13817 PyObject * obj3 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13824 if (!SWIG_IsOK(res1)) {
13825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13826 }
13827 arg1 = reinterpret_cast< wxImage * >(argp1);
13828 ecode2 = SWIG_AsVal_int(obj1, &val2);
13829 if (!SWIG_IsOK(ecode2)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13831 }
13832 arg2 = static_cast< int >(val2);
13833 ecode3 = SWIG_AsVal_int(obj2, &val3);
13834 if (!SWIG_IsOK(ecode3)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13836 }
13837 arg3 = static_cast< int >(val3);
13838 if (obj3) {
13839 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13840 if (!SWIG_IsOK(ecode4)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13842 }
13843 arg4 = static_cast< bool >(val4);
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 (arg1)->Create(arg2,arg3,arg4);
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_Py_Void();
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13859 PyObject *resultobj = 0;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 void *argp1 = 0 ;
13862 int res1 = 0 ;
13863 PyObject *swig_obj[1] ;
13864
13865 if (!args) SWIG_fail;
13866 swig_obj[0] = args;
13867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13868 if (!SWIG_IsOK(res1)) {
13869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13870 }
13871 arg1 = reinterpret_cast< wxImage * >(argp1);
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 (arg1)->Destroy();
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_Py_Void();
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxImage *arg1 = (wxImage *) 0 ;
13888 int arg2 ;
13889 int arg3 ;
13890 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13891 SwigValueWrapper<wxImage > result;
13892 void *argp1 = 0 ;
13893 int res1 = 0 ;
13894 int val2 ;
13895 int ecode2 = 0 ;
13896 int val3 ;
13897 int ecode3 = 0 ;
13898 int val4 ;
13899 int ecode4 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 PyObject * obj3 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 if (obj3) {
13925 ecode4 = SWIG_AsVal_int(obj3, &val4);
13926 if (!SWIG_IsOK(ecode4)) {
13927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13928 }
13929 arg4 = static_cast< int >(val4);
13930 }
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 result = (arg1)->Scale(arg2,arg3,arg4);
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13938 return resultobj;
13939 fail:
13940 return NULL;
13941 }
13942
13943
13944 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj = 0;
13946 wxImage *arg1 = (wxImage *) 0 ;
13947 int arg2 ;
13948 int arg3 ;
13949 SwigValueWrapper<wxImage > result;
13950 void *argp1 = 0 ;
13951 int res1 = 0 ;
13952 int val2 ;
13953 int ecode2 = 0 ;
13954 int val3 ;
13955 int ecode3 = 0 ;
13956 PyObject * obj0 = 0 ;
13957 PyObject * obj1 = 0 ;
13958 PyObject * obj2 = 0 ;
13959 char * kwnames[] = {
13960 (char *) "self",(char *) "width",(char *) "height", NULL
13961 };
13962
13963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13965 if (!SWIG_IsOK(res1)) {
13966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13967 }
13968 arg1 = reinterpret_cast< wxImage * >(argp1);
13969 ecode2 = SWIG_AsVal_int(obj1, &val2);
13970 if (!SWIG_IsOK(ecode2)) {
13971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13972 }
13973 arg2 = static_cast< int >(val2);
13974 ecode3 = SWIG_AsVal_int(obj2, &val3);
13975 if (!SWIG_IsOK(ecode3)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13977 }
13978 arg3 = static_cast< int >(val3);
13979 {
13980 PyThreadState* __tstate = wxPyBeginAllowThreads();
13981 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13982 wxPyEndAllowThreads(__tstate);
13983 if (PyErr_Occurred()) SWIG_fail;
13984 }
13985 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13986 return resultobj;
13987 fail:
13988 return NULL;
13989 }
13990
13991
13992 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13993 PyObject *resultobj = 0;
13994 wxImage *arg1 = (wxImage *) 0 ;
13995 int arg2 ;
13996 int arg3 ;
13997 SwigValueWrapper<wxImage > result;
13998 void *argp1 = 0 ;
13999 int res1 = 0 ;
14000 int val2 ;
14001 int ecode2 = 0 ;
14002 int val3 ;
14003 int ecode3 = 0 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 PyObject * obj2 = 0 ;
14007 char * kwnames[] = {
14008 (char *) "self",(char *) "width",(char *) "height", NULL
14009 };
14010
14011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14013 if (!SWIG_IsOK(res1)) {
14014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14015 }
14016 arg1 = reinterpret_cast< wxImage * >(argp1);
14017 ecode2 = SWIG_AsVal_int(obj1, &val2);
14018 if (!SWIG_IsOK(ecode2)) {
14019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14020 }
14021 arg2 = static_cast< int >(val2);
14022 ecode3 = SWIG_AsVal_int(obj2, &val3);
14023 if (!SWIG_IsOK(ecode3)) {
14024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14025 }
14026 arg3 = static_cast< int >(val3);
14027 {
14028 PyThreadState* __tstate = wxPyBeginAllowThreads();
14029 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14030 wxPyEndAllowThreads(__tstate);
14031 if (PyErr_Occurred()) SWIG_fail;
14032 }
14033 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14034 return resultobj;
14035 fail:
14036 return NULL;
14037 }
14038
14039
14040 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj = 0;
14042 wxImage *arg1 = (wxImage *) 0 ;
14043 int arg2 ;
14044 SwigValueWrapper<wxImage > result;
14045 void *argp1 = 0 ;
14046 int res1 = 0 ;
14047 int val2 ;
14048 int ecode2 = 0 ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "radius", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (arg1)->Blur(arg2);
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj = 0;
14081 wxImage *arg1 = (wxImage *) 0 ;
14082 int arg2 ;
14083 SwigValueWrapper<wxImage > result;
14084 void *argp1 = 0 ;
14085 int res1 = 0 ;
14086 int val2 ;
14087 int ecode2 = 0 ;
14088 PyObject * obj0 = 0 ;
14089 PyObject * obj1 = 0 ;
14090 char * kwnames[] = {
14091 (char *) "self",(char *) "radius", NULL
14092 };
14093
14094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14096 if (!SWIG_IsOK(res1)) {
14097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14098 }
14099 arg1 = reinterpret_cast< wxImage * >(argp1);
14100 ecode2 = SWIG_AsVal_int(obj1, &val2);
14101 if (!SWIG_IsOK(ecode2)) {
14102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14103 }
14104 arg2 = static_cast< int >(val2);
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (arg1)->BlurHorizontal(arg2);
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj = 0;
14120 wxImage *arg1 = (wxImage *) 0 ;
14121 int arg2 ;
14122 SwigValueWrapper<wxImage > result;
14123 void *argp1 = 0 ;
14124 int res1 = 0 ;
14125 int val2 ;
14126 int ecode2 = 0 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 char * kwnames[] = {
14130 (char *) "self",(char *) "radius", NULL
14131 };
14132
14133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14135 if (!SWIG_IsOK(res1)) {
14136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14137 }
14138 arg1 = reinterpret_cast< wxImage * >(argp1);
14139 ecode2 = SWIG_AsVal_int(obj1, &val2);
14140 if (!SWIG_IsOK(ecode2)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14142 }
14143 arg2 = static_cast< int >(val2);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (arg1)->BlurVertical(arg2);
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxImage *arg1 = (wxImage *) 0 ;
14160 int arg2 ;
14161 int arg3 ;
14162 SwigValueWrapper<wxImage > result;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 int val2 ;
14166 int ecode2 = 0 ;
14167 int val3 ;
14168 int ecode3 = 0 ;
14169 PyObject * obj0 = 0 ;
14170 PyObject * obj1 = 0 ;
14171 PyObject * obj2 = 0 ;
14172 char * kwnames[] = {
14173 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14174 };
14175
14176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14180 }
14181 arg1 = reinterpret_cast< wxImage * >(argp1);
14182 ecode2 = SWIG_AsVal_int(obj1, &val2);
14183 if (!SWIG_IsOK(ecode2)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14185 }
14186 arg2 = static_cast< int >(val2);
14187 ecode3 = SWIG_AsVal_int(obj2, &val3);
14188 if (!SWIG_IsOK(ecode3)) {
14189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14190 }
14191 arg3 = static_cast< int >(val3);
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxImage *arg1 = (wxImage *) 0 ;
14208 int arg2 ;
14209 int arg3 ;
14210 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14211 wxImage *result = 0 ;
14212 void *argp1 = 0 ;
14213 int res1 = 0 ;
14214 int val2 ;
14215 int ecode2 = 0 ;
14216 int val3 ;
14217 int ecode3 = 0 ;
14218 int val4 ;
14219 int ecode4 = 0 ;
14220 PyObject * obj0 = 0 ;
14221 PyObject * obj1 = 0 ;
14222 PyObject * obj2 = 0 ;
14223 PyObject * obj3 = 0 ;
14224 char * kwnames[] = {
14225 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14226 };
14227
14228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14230 if (!SWIG_IsOK(res1)) {
14231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14232 }
14233 arg1 = reinterpret_cast< wxImage * >(argp1);
14234 ecode2 = SWIG_AsVal_int(obj1, &val2);
14235 if (!SWIG_IsOK(ecode2)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14237 }
14238 arg2 = static_cast< int >(val2);
14239 ecode3 = SWIG_AsVal_int(obj2, &val3);
14240 if (!SWIG_IsOK(ecode3)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14242 }
14243 arg3 = static_cast< int >(val3);
14244 if (obj3) {
14245 ecode4 = SWIG_AsVal_int(obj3, &val4);
14246 if (!SWIG_IsOK(ecode4)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14248 }
14249 arg4 = static_cast< int >(val4);
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 {
14254 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14255 result = (wxImage *) &_result_ref;
14256 }
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj = 0;
14269 wxImage *arg1 = (wxImage *) 0 ;
14270 wxSize *arg2 = 0 ;
14271 wxPoint *arg3 = 0 ;
14272 int arg4 = (int) -1 ;
14273 int arg5 = (int) -1 ;
14274 int arg6 = (int) -1 ;
14275 wxImage *result = 0 ;
14276 void *argp1 = 0 ;
14277 int res1 = 0 ;
14278 wxSize temp2 ;
14279 wxPoint temp3 ;
14280 int val4 ;
14281 int ecode4 = 0 ;
14282 int val5 ;
14283 int ecode5 = 0 ;
14284 int val6 ;
14285 int ecode6 = 0 ;
14286 PyObject * obj0 = 0 ;
14287 PyObject * obj1 = 0 ;
14288 PyObject * obj2 = 0 ;
14289 PyObject * obj3 = 0 ;
14290 PyObject * obj4 = 0 ;
14291 PyObject * obj5 = 0 ;
14292 char * kwnames[] = {
14293 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14294 };
14295
14296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14300 }
14301 arg1 = reinterpret_cast< wxImage * >(argp1);
14302 {
14303 arg2 = &temp2;
14304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14305 }
14306 {
14307 arg3 = &temp3;
14308 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14309 }
14310 if (obj3) {
14311 ecode4 = SWIG_AsVal_int(obj3, &val4);
14312 if (!SWIG_IsOK(ecode4)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14314 }
14315 arg4 = static_cast< int >(val4);
14316 }
14317 if (obj4) {
14318 ecode5 = SWIG_AsVal_int(obj4, &val5);
14319 if (!SWIG_IsOK(ecode5)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14321 }
14322 arg5 = static_cast< int >(val5);
14323 }
14324 if (obj5) {
14325 ecode6 = SWIG_AsVal_int(obj5, &val6);
14326 if (!SWIG_IsOK(ecode6)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14328 }
14329 arg6 = static_cast< int >(val6);
14330 }
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 {
14334 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14335 result = (wxImage *) &_result_ref;
14336 }
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = 0;
14349 wxImage *arg1 = (wxImage *) 0 ;
14350 int arg2 ;
14351 int arg3 ;
14352 byte arg4 ;
14353 byte arg5 ;
14354 byte arg6 ;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 int val2 ;
14358 int ecode2 = 0 ;
14359 int val3 ;
14360 int ecode3 = 0 ;
14361 unsigned char val4 ;
14362 int ecode4 = 0 ;
14363 unsigned char val5 ;
14364 int ecode5 = 0 ;
14365 unsigned char val6 ;
14366 int ecode6 = 0 ;
14367 PyObject * obj0 = 0 ;
14368 PyObject * obj1 = 0 ;
14369 PyObject * obj2 = 0 ;
14370 PyObject * obj3 = 0 ;
14371 PyObject * obj4 = 0 ;
14372 PyObject * obj5 = 0 ;
14373 char * kwnames[] = {
14374 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14375 };
14376
14377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14379 if (!SWIG_IsOK(res1)) {
14380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14381 }
14382 arg1 = reinterpret_cast< wxImage * >(argp1);
14383 ecode2 = SWIG_AsVal_int(obj1, &val2);
14384 if (!SWIG_IsOK(ecode2)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14386 }
14387 arg2 = static_cast< int >(val2);
14388 ecode3 = SWIG_AsVal_int(obj2, &val3);
14389 if (!SWIG_IsOK(ecode3)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14391 }
14392 arg3 = static_cast< int >(val3);
14393 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14394 if (!SWIG_IsOK(ecode4)) {
14395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14396 }
14397 arg4 = static_cast< byte >(val4);
14398 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14399 if (!SWIG_IsOK(ecode5)) {
14400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14401 }
14402 arg5 = static_cast< byte >(val5);
14403 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14404 if (!SWIG_IsOK(ecode6)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14406 }
14407 arg6 = static_cast< byte >(val6);
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_Py_Void();
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj = 0;
14423 wxImage *arg1 = (wxImage *) 0 ;
14424 wxRect *arg2 = 0 ;
14425 byte arg3 ;
14426 byte arg4 ;
14427 byte arg5 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 wxRect temp2 ;
14431 unsigned char val3 ;
14432 int ecode3 = 0 ;
14433 unsigned char val4 ;
14434 int ecode4 = 0 ;
14435 unsigned char val5 ;
14436 int ecode5 = 0 ;
14437 PyObject * obj0 = 0 ;
14438 PyObject * obj1 = 0 ;
14439 PyObject * obj2 = 0 ;
14440 PyObject * obj3 = 0 ;
14441 PyObject * obj4 = 0 ;
14442 char * kwnames[] = {
14443 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14444 };
14445
14446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14448 if (!SWIG_IsOK(res1)) {
14449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14450 }
14451 arg1 = reinterpret_cast< wxImage * >(argp1);
14452 {
14453 arg2 = &temp2;
14454 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14455 }
14456 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14457 if (!SWIG_IsOK(ecode3)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14459 }
14460 arg3 = static_cast< byte >(val3);
14461 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14462 if (!SWIG_IsOK(ecode4)) {
14463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14464 }
14465 arg4 = static_cast< byte >(val4);
14466 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14467 if (!SWIG_IsOK(ecode5)) {
14468 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14469 }
14470 arg5 = static_cast< byte >(val5);
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 resultobj = SWIG_Py_Void();
14478 return resultobj;
14479 fail:
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj = 0;
14486 wxImage *arg1 = (wxImage *) 0 ;
14487 int arg2 ;
14488 int arg3 ;
14489 byte result;
14490 void *argp1 = 0 ;
14491 int res1 = 0 ;
14492 int val2 ;
14493 int ecode2 = 0 ;
14494 int val3 ;
14495 int ecode3 = 0 ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 PyObject * obj2 = 0 ;
14499 char * kwnames[] = {
14500 (char *) "self",(char *) "x",(char *) "y", NULL
14501 };
14502
14503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14505 if (!SWIG_IsOK(res1)) {
14506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14507 }
14508 arg1 = reinterpret_cast< wxImage * >(argp1);
14509 ecode2 = SWIG_AsVal_int(obj1, &val2);
14510 if (!SWIG_IsOK(ecode2)) {
14511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14512 }
14513 arg2 = static_cast< int >(val2);
14514 ecode3 = SWIG_AsVal_int(obj2, &val3);
14515 if (!SWIG_IsOK(ecode3)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14517 }
14518 arg3 = static_cast< int >(val3);
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (byte)(arg1)->GetRed(arg2,arg3);
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14526 return resultobj;
14527 fail:
14528 return NULL;
14529 }
14530
14531
14532 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14533 PyObject *resultobj = 0;
14534 wxImage *arg1 = (wxImage *) 0 ;
14535 int arg2 ;
14536 int arg3 ;
14537 byte result;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 int val2 ;
14541 int ecode2 = 0 ;
14542 int val3 ;
14543 int ecode3 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "x",(char *) "y", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14555 }
14556 arg1 = reinterpret_cast< wxImage * >(argp1);
14557 ecode2 = SWIG_AsVal_int(obj1, &val2);
14558 if (!SWIG_IsOK(ecode2)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14560 }
14561 arg2 = static_cast< int >(val2);
14562 ecode3 = SWIG_AsVal_int(obj2, &val3);
14563 if (!SWIG_IsOK(ecode3)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14565 }
14566 arg3 = static_cast< int >(val3);
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (byte)(arg1)->GetGreen(arg2,arg3);
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14574 return resultobj;
14575 fail:
14576 return NULL;
14577 }
14578
14579
14580 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14581 PyObject *resultobj = 0;
14582 wxImage *arg1 = (wxImage *) 0 ;
14583 int arg2 ;
14584 int arg3 ;
14585 byte result;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 int val2 ;
14589 int ecode2 = 0 ;
14590 int val3 ;
14591 int ecode3 = 0 ;
14592 PyObject * obj0 = 0 ;
14593 PyObject * obj1 = 0 ;
14594 PyObject * obj2 = 0 ;
14595 char * kwnames[] = {
14596 (char *) "self",(char *) "x",(char *) "y", NULL
14597 };
14598
14599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14601 if (!SWIG_IsOK(res1)) {
14602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14603 }
14604 arg1 = reinterpret_cast< wxImage * >(argp1);
14605 ecode2 = SWIG_AsVal_int(obj1, &val2);
14606 if (!SWIG_IsOK(ecode2)) {
14607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14608 }
14609 arg2 = static_cast< int >(val2);
14610 ecode3 = SWIG_AsVal_int(obj2, &val3);
14611 if (!SWIG_IsOK(ecode3)) {
14612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14613 }
14614 arg3 = static_cast< int >(val3);
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (byte)(arg1)->GetBlue(arg2,arg3);
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj = 0;
14630 wxImage *arg1 = (wxImage *) 0 ;
14631 int arg2 ;
14632 int arg3 ;
14633 byte arg4 ;
14634 void *argp1 = 0 ;
14635 int res1 = 0 ;
14636 int val2 ;
14637 int ecode2 = 0 ;
14638 int val3 ;
14639 int ecode3 = 0 ;
14640 unsigned char val4 ;
14641 int ecode4 = 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 PyObject * obj2 = 0 ;
14645 PyObject * obj3 = 0 ;
14646 char * kwnames[] = {
14647 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14648 };
14649
14650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14654 }
14655 arg1 = reinterpret_cast< wxImage * >(argp1);
14656 ecode2 = SWIG_AsVal_int(obj1, &val2);
14657 if (!SWIG_IsOK(ecode2)) {
14658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14659 }
14660 arg2 = static_cast< int >(val2);
14661 ecode3 = SWIG_AsVal_int(obj2, &val3);
14662 if (!SWIG_IsOK(ecode3)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14664 }
14665 arg3 = static_cast< int >(val3);
14666 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14667 if (!SWIG_IsOK(ecode4)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14669 }
14670 arg4 = static_cast< byte >(val4);
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 (arg1)->SetAlpha(arg2,arg3,arg4);
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = SWIG_Py_Void();
14678 return resultobj;
14679 fail:
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14685 PyObject *resultobj = 0;
14686 wxImage *arg1 = (wxImage *) 0 ;
14687 int arg2 ;
14688 int arg3 ;
14689 byte result;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 int val2 ;
14693 int ecode2 = 0 ;
14694 int val3 ;
14695 int ecode3 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 PyObject * obj2 = 0 ;
14699 char * kwnames[] = {
14700 (char *) "self",(char *) "x",(char *) "y", NULL
14701 };
14702
14703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14707 }
14708 arg1 = reinterpret_cast< wxImage * >(argp1);
14709 ecode2 = SWIG_AsVal_int(obj1, &val2);
14710 if (!SWIG_IsOK(ecode2)) {
14711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14712 }
14713 arg2 = static_cast< int >(val2);
14714 ecode3 = SWIG_AsVal_int(obj2, &val3);
14715 if (!SWIG_IsOK(ecode3)) {
14716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14717 }
14718 arg3 = static_cast< int >(val3);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImage *arg1 = (wxImage *) 0 ;
14735 bool result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (bool)(arg1)->HasAlpha();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 {
14754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14755 }
14756 return resultobj;
14757 fail:
14758 return NULL;
14759 }
14760
14761
14762 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14763 PyObject *resultobj = 0;
14764 wxImage *arg1 = (wxImage *) 0 ;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14774 }
14775 arg1 = reinterpret_cast< wxImage * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 (arg1)->InitAlpha();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 resultobj = SWIG_Py_Void();
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj = 0;
14791 wxImage *arg1 = (wxImage *) 0 ;
14792 int arg2 ;
14793 int arg3 ;
14794 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14795 bool result;
14796 void *argp1 = 0 ;
14797 int res1 = 0 ;
14798 int val2 ;
14799 int ecode2 = 0 ;
14800 int val3 ;
14801 int ecode3 = 0 ;
14802 unsigned char val4 ;
14803 int ecode4 = 0 ;
14804 PyObject * obj0 = 0 ;
14805 PyObject * obj1 = 0 ;
14806 PyObject * obj2 = 0 ;
14807 PyObject * obj3 = 0 ;
14808 char * kwnames[] = {
14809 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14810 };
14811
14812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14814 if (!SWIG_IsOK(res1)) {
14815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14816 }
14817 arg1 = reinterpret_cast< wxImage * >(argp1);
14818 ecode2 = SWIG_AsVal_int(obj1, &val2);
14819 if (!SWIG_IsOK(ecode2)) {
14820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14821 }
14822 arg2 = static_cast< int >(val2);
14823 ecode3 = SWIG_AsVal_int(obj2, &val3);
14824 if (!SWIG_IsOK(ecode3)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14826 }
14827 arg3 = static_cast< int >(val3);
14828 if (obj3) {
14829 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14830 if (!SWIG_IsOK(ecode4)) {
14831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14832 }
14833 arg4 = static_cast< byte >(val4);
14834 }
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14843 }
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj = 0;
14852 wxImage *arg1 = (wxImage *) 0 ;
14853 byte *arg2 = (byte *) 0 ;
14854 byte *arg3 = (byte *) 0 ;
14855 byte *arg4 = (byte *) 0 ;
14856 byte arg5 = (byte) 0 ;
14857 byte arg6 = (byte) 0 ;
14858 byte arg7 = (byte) 0 ;
14859 bool result;
14860 void *argp1 = 0 ;
14861 int res1 = 0 ;
14862 byte temp2 ;
14863 int res2 = SWIG_TMPOBJ ;
14864 byte temp3 ;
14865 int res3 = SWIG_TMPOBJ ;
14866 byte temp4 ;
14867 int res4 = SWIG_TMPOBJ ;
14868 unsigned char val5 ;
14869 int ecode5 = 0 ;
14870 unsigned char val6 ;
14871 int ecode6 = 0 ;
14872 unsigned char val7 ;
14873 int ecode7 = 0 ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 PyObject * obj3 = 0 ;
14878 char * kwnames[] = {
14879 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14880 };
14881
14882 arg2 = &temp2;
14883 arg3 = &temp3;
14884 arg4 = &temp4;
14885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14887 if (!SWIG_IsOK(res1)) {
14888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14889 }
14890 arg1 = reinterpret_cast< wxImage * >(argp1);
14891 if (obj1) {
14892 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14893 if (!SWIG_IsOK(ecode5)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14895 }
14896 arg5 = static_cast< byte >(val5);
14897 }
14898 if (obj2) {
14899 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14900 if (!SWIG_IsOK(ecode6)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14902 }
14903 arg6 = static_cast< byte >(val6);
14904 }
14905 if (obj3) {
14906 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14907 if (!SWIG_IsOK(ecode7)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14909 }
14910 arg7 = static_cast< byte >(val7);
14911 }
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 {
14919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14920 }
14921 if (SWIG_IsTmpObj(res2)) {
14922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14923 } else {
14924 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14926 }
14927 if (SWIG_IsTmpObj(res3)) {
14928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14929 } else {
14930 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14932 }
14933 if (SWIG_IsTmpObj(res4)) {
14934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14935 } else {
14936 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14938 }
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj = 0;
14947 wxImage *arg1 = (wxImage *) 0 ;
14948 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14949 bool result;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 unsigned char val2 ;
14953 int ecode2 = 0 ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 char * kwnames[] = {
14957 (char *) "self",(char *) "threshold", NULL
14958 };
14959
14960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14962 if (!SWIG_IsOK(res1)) {
14963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14964 }
14965 arg1 = reinterpret_cast< wxImage * >(argp1);
14966 if (obj1) {
14967 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14968 if (!SWIG_IsOK(ecode2)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14970 }
14971 arg2 = static_cast< byte >(val2);
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 {
14980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14981 }
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImage *arg1 = (wxImage *) 0 ;
14991 byte arg2 ;
14992 byte arg3 ;
14993 byte arg4 ;
14994 bool result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 unsigned char val2 ;
14998 int ecode2 = 0 ;
14999 unsigned char val3 ;
15000 int ecode3 = 0 ;
15001 unsigned char val4 ;
15002 int ecode4 = 0 ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 PyObject * obj2 = 0 ;
15006 PyObject * obj3 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImage * >(argp1);
15017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15018 if (!SWIG_IsOK(ecode2)) {
15019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15020 }
15021 arg2 = static_cast< byte >(val2);
15022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15023 if (!SWIG_IsOK(ecode3)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15025 }
15026 arg3 = static_cast< byte >(val3);
15027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15028 if (!SWIG_IsOK(ecode4)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15030 }
15031 arg4 = static_cast< byte >(val4);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 {
15039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15040 }
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 wxImage *arg2 = 0 ;
15051 byte arg3 ;
15052 byte arg4 ;
15053 byte arg5 ;
15054 bool result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 void *argp2 = 0 ;
15058 int res2 = 0 ;
15059 unsigned char val3 ;
15060 int ecode3 = 0 ;
15061 unsigned char val4 ;
15062 int ecode4 = 0 ;
15063 unsigned char val5 ;
15064 int ecode5 = 0 ;
15065 PyObject * obj0 = 0 ;
15066 PyObject * obj1 = 0 ;
15067 PyObject * obj2 = 0 ;
15068 PyObject * obj3 = 0 ;
15069 PyObject * obj4 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15078 }
15079 arg1 = reinterpret_cast< wxImage * >(argp1);
15080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15081 if (!SWIG_IsOK(res2)) {
15082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15083 }
15084 if (!argp2) {
15085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15086 }
15087 arg2 = reinterpret_cast< wxImage * >(argp2);
15088 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15089 if (!SWIG_IsOK(ecode3)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15091 }
15092 arg3 = static_cast< byte >(val3);
15093 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15094 if (!SWIG_IsOK(ecode4)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15096 }
15097 arg4 = static_cast< byte >(val4);
15098 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15099 if (!SWIG_IsOK(ecode5)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15101 }
15102 arg5 = static_cast< byte >(val5);
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 {
15110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15111 }
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj = 0;
15120 wxString *arg1 = 0 ;
15121 bool result;
15122 bool temp1 = false ;
15123 PyObject * obj0 = 0 ;
15124 char * kwnames[] = {
15125 (char *) "filename", NULL
15126 };
15127
15128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15129 {
15130 arg1 = wxString_in_helper(obj0);
15131 if (arg1 == NULL) SWIG_fail;
15132 temp1 = true;
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 {
15141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15142 }
15143 {
15144 if (temp1)
15145 delete arg1;
15146 }
15147 return resultobj;
15148 fail:
15149 {
15150 if (temp1)
15151 delete arg1;
15152 }
15153 return NULL;
15154 }
15155
15156
15157 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15158 PyObject *resultobj = 0;
15159 wxString *arg1 = 0 ;
15160 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15161 int result;
15162 bool temp1 = false ;
15163 long val2 ;
15164 int ecode2 = 0 ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char * kwnames[] = {
15168 (char *) "filename",(char *) "type", NULL
15169 };
15170
15171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15172 {
15173 arg1 = wxString_in_helper(obj0);
15174 if (arg1 == NULL) SWIG_fail;
15175 temp1 = true;
15176 }
15177 if (obj1) {
15178 ecode2 = SWIG_AsVal_long(obj1, &val2);
15179 if (!SWIG_IsOK(ecode2)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15181 }
15182 arg2 = static_cast< long >(val2);
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 resultobj = SWIG_From_int(static_cast< int >(result));
15191 {
15192 if (temp1)
15193 delete arg1;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (temp1)
15199 delete arg1;
15200 }
15201 return NULL;
15202 }
15203
15204
15205 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj = 0;
15207 wxImage *arg1 = (wxImage *) 0 ;
15208 wxString *arg2 = 0 ;
15209 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15210 int arg4 = (int) -1 ;
15211 bool result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 bool temp2 = false ;
15215 long val3 ;
15216 int ecode3 = 0 ;
15217 int val4 ;
15218 int ecode4 = 0 ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 PyObject * obj2 = 0 ;
15222 PyObject * obj3 = 0 ;
15223 char * kwnames[] = {
15224 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15225 };
15226
15227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15229 if (!SWIG_IsOK(res1)) {
15230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15231 }
15232 arg1 = reinterpret_cast< wxImage * >(argp1);
15233 {
15234 arg2 = wxString_in_helper(obj1);
15235 if (arg2 == NULL) SWIG_fail;
15236 temp2 = true;
15237 }
15238 if (obj2) {
15239 ecode3 = SWIG_AsVal_long(obj2, &val3);
15240 if (!SWIG_IsOK(ecode3)) {
15241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15242 }
15243 arg3 = static_cast< long >(val3);
15244 }
15245 if (obj3) {
15246 ecode4 = SWIG_AsVal_int(obj3, &val4);
15247 if (!SWIG_IsOK(ecode4)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15249 }
15250 arg4 = static_cast< int >(val4);
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 {
15259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15260 }
15261 {
15262 if (temp2)
15263 delete arg2;
15264 }
15265 return resultobj;
15266 fail:
15267 {
15268 if (temp2)
15269 delete arg2;
15270 }
15271 return NULL;
15272 }
15273
15274
15275 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj = 0;
15277 wxImage *arg1 = (wxImage *) 0 ;
15278 wxString *arg2 = 0 ;
15279 wxString *arg3 = 0 ;
15280 int arg4 = (int) -1 ;
15281 bool result;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 bool temp2 = false ;
15285 bool temp3 = false ;
15286 int val4 ;
15287 int ecode4 = 0 ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 PyObject * obj2 = 0 ;
15291 PyObject * obj3 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 arg2 = wxString_in_helper(obj1);
15304 if (arg2 == NULL) SWIG_fail;
15305 temp2 = true;
15306 }
15307 {
15308 arg3 = wxString_in_helper(obj2);
15309 if (arg3 == NULL) SWIG_fail;
15310 temp3 = true;
15311 }
15312 if (obj3) {
15313 ecode4 = SWIG_AsVal_int(obj3, &val4);
15314 if (!SWIG_IsOK(ecode4)) {
15315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15316 }
15317 arg4 = static_cast< int >(val4);
15318 }
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 {
15329 if (temp2)
15330 delete arg2;
15331 }
15332 {
15333 if (temp3)
15334 delete arg3;
15335 }
15336 return resultobj;
15337 fail:
15338 {
15339 if (temp2)
15340 delete arg2;
15341 }
15342 {
15343 if (temp3)
15344 delete arg3;
15345 }
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj = 0;
15352 wxImage *arg1 = (wxImage *) 0 ;
15353 wxString *arg2 = 0 ;
15354 int arg3 ;
15355 bool result;
15356 void *argp1 = 0 ;
15357 int res1 = 0 ;
15358 bool temp2 = false ;
15359 int val3 ;
15360 int ecode3 = 0 ;
15361 PyObject * obj0 = 0 ;
15362 PyObject * obj1 = 0 ;
15363 PyObject * obj2 = 0 ;
15364 char * kwnames[] = {
15365 (char *) "self",(char *) "name",(char *) "type", NULL
15366 };
15367
15368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15370 if (!SWIG_IsOK(res1)) {
15371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15372 }
15373 arg1 = reinterpret_cast< wxImage * >(argp1);
15374 {
15375 arg2 = wxString_in_helper(obj1);
15376 if (arg2 == NULL) SWIG_fail;
15377 temp2 = true;
15378 }
15379 ecode3 = SWIG_AsVal_int(obj2, &val3);
15380 if (!SWIG_IsOK(ecode3)) {
15381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15382 }
15383 arg3 = static_cast< int >(val3);
15384 {
15385 PyThreadState* __tstate = wxPyBeginAllowThreads();
15386 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 {
15391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15392 }
15393 {
15394 if (temp2)
15395 delete arg2;
15396 }
15397 return resultobj;
15398 fail:
15399 {
15400 if (temp2)
15401 delete arg2;
15402 }
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxImage *arg1 = (wxImage *) 0 ;
15410 wxString *arg2 = 0 ;
15411 wxString *arg3 = 0 ;
15412 bool result;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 bool temp2 = false ;
15416 bool temp3 = false ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 PyObject * obj2 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 arg2 = wxString_in_helper(obj1);
15432 if (arg2 == NULL) SWIG_fail;
15433 temp2 = true;
15434 }
15435 {
15436 arg3 = wxString_in_helper(obj2);
15437 if (arg3 == NULL) SWIG_fail;
15438 temp3 = true;
15439 }
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15443 wxPyEndAllowThreads(__tstate);
15444 if (PyErr_Occurred()) SWIG_fail;
15445 }
15446 {
15447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15448 }
15449 {
15450 if (temp2)
15451 delete arg2;
15452 }
15453 {
15454 if (temp3)
15455 delete arg3;
15456 }
15457 return resultobj;
15458 fail:
15459 {
15460 if (temp2)
15461 delete arg2;
15462 }
15463 {
15464 if (temp3)
15465 delete arg3;
15466 }
15467 return NULL;
15468 }
15469
15470
15471 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj = 0;
15473 wxInputStream *arg1 = 0 ;
15474 bool result;
15475 wxPyInputStream *temp1 ;
15476 bool created1 ;
15477 PyObject * obj0 = 0 ;
15478 char * kwnames[] = {
15479 (char *) "stream", NULL
15480 };
15481
15482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15483 {
15484 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15485 arg1 = temp1->m_wxis;
15486 created1 = false;
15487 } else {
15488 PyErr_Clear(); // clear the failure of the wxPyConvert above
15489 arg1 = wxPyCBInputStream_create(obj0, false);
15490 if (arg1 == NULL) {
15491 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15492 SWIG_fail;
15493 }
15494 created1 = true;
15495 }
15496 }
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 result = (bool)wxImage::CanRead(*arg1);
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 {
15504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15505 }
15506 {
15507 if (created1) delete arg1;
15508 }
15509 return resultobj;
15510 fail:
15511 {
15512 if (created1) delete arg1;
15513 }
15514 return NULL;
15515 }
15516
15517
15518 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj = 0;
15520 wxImage *arg1 = (wxImage *) 0 ;
15521 wxInputStream *arg2 = 0 ;
15522 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15523 int arg4 = (int) -1 ;
15524 bool result;
15525 void *argp1 = 0 ;
15526 int res1 = 0 ;
15527 wxPyInputStream *temp2 ;
15528 bool created2 ;
15529 long val3 ;
15530 int ecode3 = 0 ;
15531 int val4 ;
15532 int ecode4 = 0 ;
15533 PyObject * obj0 = 0 ;
15534 PyObject * obj1 = 0 ;
15535 PyObject * obj2 = 0 ;
15536 PyObject * obj3 = 0 ;
15537 char * kwnames[] = {
15538 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15539 };
15540
15541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15543 if (!SWIG_IsOK(res1)) {
15544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15545 }
15546 arg1 = reinterpret_cast< wxImage * >(argp1);
15547 {
15548 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15549 arg2 = temp2->m_wxis;
15550 created2 = false;
15551 } else {
15552 PyErr_Clear(); // clear the failure of the wxPyConvert above
15553 arg2 = wxPyCBInputStream_create(obj1, false);
15554 if (arg2 == NULL) {
15555 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15556 SWIG_fail;
15557 }
15558 created2 = true;
15559 }
15560 }
15561 if (obj2) {
15562 ecode3 = SWIG_AsVal_long(obj2, &val3);
15563 if (!SWIG_IsOK(ecode3)) {
15564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15565 }
15566 arg3 = static_cast< long >(val3);
15567 }
15568 if (obj3) {
15569 ecode4 = SWIG_AsVal_int(obj3, &val4);
15570 if (!SWIG_IsOK(ecode4)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15572 }
15573 arg4 = static_cast< int >(val4);
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 {
15582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15583 }
15584 {
15585 if (created2) delete arg2;
15586 }
15587 return resultobj;
15588 fail:
15589 {
15590 if (created2) delete arg2;
15591 }
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 wxInputStream *arg2 = 0 ;
15600 wxString *arg3 = 0 ;
15601 int arg4 = (int) -1 ;
15602 bool result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 wxPyInputStream *temp2 ;
15606 bool created2 ;
15607 bool temp3 = false ;
15608 int val4 ;
15609 int ecode4 = 0 ;
15610 PyObject * obj0 = 0 ;
15611 PyObject * obj1 = 0 ;
15612 PyObject * obj2 = 0 ;
15613 PyObject * obj3 = 0 ;
15614 char * kwnames[] = {
15615 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15616 };
15617
15618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15620 if (!SWIG_IsOK(res1)) {
15621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15622 }
15623 arg1 = reinterpret_cast< wxImage * >(argp1);
15624 {
15625 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15626 arg2 = temp2->m_wxis;
15627 created2 = false;
15628 } else {
15629 PyErr_Clear(); // clear the failure of the wxPyConvert above
15630 arg2 = wxPyCBInputStream_create(obj1, false);
15631 if (arg2 == NULL) {
15632 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15633 SWIG_fail;
15634 }
15635 created2 = true;
15636 }
15637 }
15638 {
15639 arg3 = wxString_in_helper(obj2);
15640 if (arg3 == NULL) SWIG_fail;
15641 temp3 = true;
15642 }
15643 if (obj3) {
15644 ecode4 = SWIG_AsVal_int(obj3, &val4);
15645 if (!SWIG_IsOK(ecode4)) {
15646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15647 }
15648 arg4 = static_cast< int >(val4);
15649 }
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15658 }
15659 {
15660 if (created2) delete arg2;
15661 }
15662 {
15663 if (temp3)
15664 delete arg3;
15665 }
15666 return resultobj;
15667 fail:
15668 {
15669 if (created2) delete arg2;
15670 }
15671 {
15672 if (temp3)
15673 delete arg3;
15674 }
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 bool 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_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15692 }
15693 arg1 = reinterpret_cast< wxImage * >(argp1);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 result = (bool)(arg1)->IsOk();
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 {
15701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15702 }
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxImage *arg1 = (wxImage *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15722 }
15723 arg1 = reinterpret_cast< wxImage * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetWidth();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxImage *arg1 = (wxImage *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15750 }
15751 arg1 = reinterpret_cast< wxImage * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetHeight();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxImage *arg1 = (wxImage *) 0 ;
15768 wxSize result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15778 }
15779 arg1 = reinterpret_cast< wxImage * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = wxImage_GetSize(arg1);
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj = 0;
15795 wxImage *arg1 = (wxImage *) 0 ;
15796 wxRect *arg2 = 0 ;
15797 SwigValueWrapper<wxImage > result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 wxRect temp2 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 char * kwnames[] = {
15804 (char *) "self",(char *) "rect", NULL
15805 };
15806
15807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15809 if (!SWIG_IsOK(res1)) {
15810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15811 }
15812 arg1 = reinterpret_cast< wxImage * >(argp1);
15813 {
15814 arg2 = &temp2;
15815 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15816 }
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj = 0;
15832 wxImage *arg1 = (wxImage *) 0 ;
15833 wxSize *arg2 = 0 ;
15834 wxPoint *arg3 = 0 ;
15835 int arg4 = (int) -1 ;
15836 int arg5 = (int) -1 ;
15837 int arg6 = (int) -1 ;
15838 SwigValueWrapper<wxImage > result;
15839 void *argp1 = 0 ;
15840 int res1 = 0 ;
15841 wxSize temp2 ;
15842 wxPoint temp3 ;
15843 int val4 ;
15844 int ecode4 = 0 ;
15845 int val5 ;
15846 int ecode5 = 0 ;
15847 int val6 ;
15848 int ecode6 = 0 ;
15849 PyObject * obj0 = 0 ;
15850 PyObject * obj1 = 0 ;
15851 PyObject * obj2 = 0 ;
15852 PyObject * obj3 = 0 ;
15853 PyObject * obj4 = 0 ;
15854 PyObject * obj5 = 0 ;
15855 char * kwnames[] = {
15856 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15857 };
15858
15859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15861 if (!SWIG_IsOK(res1)) {
15862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15863 }
15864 arg1 = reinterpret_cast< wxImage * >(argp1);
15865 {
15866 arg2 = &temp2;
15867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15868 }
15869 {
15870 arg3 = &temp3;
15871 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15872 }
15873 if (obj3) {
15874 ecode4 = SWIG_AsVal_int(obj3, &val4);
15875 if (!SWIG_IsOK(ecode4)) {
15876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15877 }
15878 arg4 = static_cast< int >(val4);
15879 }
15880 if (obj4) {
15881 ecode5 = SWIG_AsVal_int(obj4, &val5);
15882 if (!SWIG_IsOK(ecode5)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15884 }
15885 arg5 = static_cast< int >(val5);
15886 }
15887 if (obj5) {
15888 ecode6 = SWIG_AsVal_int(obj5, &val6);
15889 if (!SWIG_IsOK(ecode6)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15891 }
15892 arg6 = static_cast< int >(val6);
15893 }
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15908 PyObject *resultobj = 0;
15909 wxImage *arg1 = (wxImage *) 0 ;
15910 SwigValueWrapper<wxImage > result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 PyObject *swig_obj[1] ;
15914
15915 if (!args) SWIG_fail;
15916 swig_obj[0] = args;
15917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15918 if (!SWIG_IsOK(res1)) {
15919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15920 }
15921 arg1 = reinterpret_cast< wxImage * >(argp1);
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (arg1)->Copy();
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 wxImage *arg1 = (wxImage *) 0 ;
15938 wxImage *arg2 = 0 ;
15939 int arg3 ;
15940 int arg4 ;
15941 void *argp1 = 0 ;
15942 int res1 = 0 ;
15943 void *argp2 = 0 ;
15944 int res2 = 0 ;
15945 int val3 ;
15946 int ecode3 = 0 ;
15947 int val4 ;
15948 int ecode4 = 0 ;
15949 PyObject * obj0 = 0 ;
15950 PyObject * obj1 = 0 ;
15951 PyObject * obj2 = 0 ;
15952 PyObject * obj3 = 0 ;
15953 char * kwnames[] = {
15954 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15955 };
15956
15957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15959 if (!SWIG_IsOK(res1)) {
15960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15961 }
15962 arg1 = reinterpret_cast< wxImage * >(argp1);
15963 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15964 if (!SWIG_IsOK(res2)) {
15965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15966 }
15967 if (!argp2) {
15968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15969 }
15970 arg2 = reinterpret_cast< wxImage * >(argp2);
15971 ecode3 = SWIG_AsVal_int(obj2, &val3);
15972 if (!SWIG_IsOK(ecode3)) {
15973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15974 }
15975 arg3 = static_cast< int >(val3);
15976 ecode4 = SWIG_AsVal_int(obj3, &val4);
15977 if (!SWIG_IsOK(ecode4)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15979 }
15980 arg4 = static_cast< int >(val4);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 resultobj = SWIG_Py_Void();
15988 return resultobj;
15989 fail:
15990 return NULL;
15991 }
15992
15993
15994 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15995 PyObject *resultobj = 0;
15996 wxImage *arg1 = (wxImage *) 0 ;
15997 PyObject *result = 0 ;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 PyObject *swig_obj[1] ;
16001
16002 if (!args) SWIG_fail;
16003 swig_obj[0] = args;
16004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16005 if (!SWIG_IsOK(res1)) {
16006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16007 }
16008 arg1 = reinterpret_cast< wxImage * >(argp1);
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 result = (PyObject *)wxImage_GetData(arg1);
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 resultobj = result;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = 0;
16024 wxImage *arg1 = (wxImage *) 0 ;
16025 buffer arg2 ;
16026 int arg3 ;
16027 void *argp1 = 0 ;
16028 int res1 = 0 ;
16029 Py_ssize_t temp2 ;
16030 PyObject * obj0 = 0 ;
16031 PyObject * obj1 = 0 ;
16032 char * kwnames[] = {
16033 (char *) "self",(char *) "data", NULL
16034 };
16035
16036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16040 }
16041 arg1 = reinterpret_cast< wxImage * >(argp1);
16042 {
16043 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16044 arg3 = (int)temp2;
16045 }
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 wxImage_SetData(arg1,arg2,arg3);
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 resultobj = SWIG_Py_Void();
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16060 PyObject *resultobj = 0;
16061 wxImage *arg1 = (wxImage *) 0 ;
16062 PyObject *result = 0 ;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 PyObject *swig_obj[1] ;
16066
16067 if (!args) SWIG_fail;
16068 swig_obj[0] = args;
16069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16070 if (!SWIG_IsOK(res1)) {
16071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16072 }
16073 arg1 = reinterpret_cast< wxImage * >(argp1);
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 resultobj = result;
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj = 0;
16089 wxImage *arg1 = (wxImage *) 0 ;
16090 buffer arg2 ;
16091 int arg3 ;
16092 void *argp1 = 0 ;
16093 int res1 = 0 ;
16094 Py_ssize_t temp2 ;
16095 PyObject * obj0 = 0 ;
16096 PyObject * obj1 = 0 ;
16097 char * kwnames[] = {
16098 (char *) "self",(char *) "data", NULL
16099 };
16100
16101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16103 if (!SWIG_IsOK(res1)) {
16104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16105 }
16106 arg1 = reinterpret_cast< wxImage * >(argp1);
16107 {
16108 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16109 arg3 = (int)temp2;
16110 }
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 wxImage_SetDataBuffer(arg1,arg2,arg3);
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 resultobj = SWIG_Py_Void();
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16125 PyObject *resultobj = 0;
16126 wxImage *arg1 = (wxImage *) 0 ;
16127 PyObject *result = 0 ;
16128 void *argp1 = 0 ;
16129 int res1 = 0 ;
16130 PyObject *swig_obj[1] ;
16131
16132 if (!args) SWIG_fail;
16133 swig_obj[0] = args;
16134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16135 if (!SWIG_IsOK(res1)) {
16136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16137 }
16138 arg1 = reinterpret_cast< wxImage * >(argp1);
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 result = (PyObject *)wxImage_GetAlphaData(arg1);
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 resultobj = result;
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 buffer arg2 ;
16156 int arg3 ;
16157 void *argp1 = 0 ;
16158 int res1 = 0 ;
16159 Py_ssize_t temp2 ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 char * kwnames[] = {
16163 (char *) "self",(char *) "alpha", NULL
16164 };
16165
16166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16170 }
16171 arg1 = reinterpret_cast< wxImage * >(argp1);
16172 {
16173 if (obj1 != Py_None) {
16174 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16175 arg3 = (int)temp2;
16176 }
16177 }
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 wxImage_SetAlphaData(arg1,arg2,arg3);
16181 wxPyEndAllowThreads(__tstate);
16182 if (PyErr_Occurred()) SWIG_fail;
16183 }
16184 resultobj = SWIG_Py_Void();
16185 return resultobj;
16186 fail:
16187 return NULL;
16188 }
16189
16190
16191 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16192 PyObject *resultobj = 0;
16193 wxImage *arg1 = (wxImage *) 0 ;
16194 PyObject *result = 0 ;
16195 void *argp1 = 0 ;
16196 int res1 = 0 ;
16197 PyObject *swig_obj[1] ;
16198
16199 if (!args) SWIG_fail;
16200 swig_obj[0] = args;
16201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16202 if (!SWIG_IsOK(res1)) {
16203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16204 }
16205 arg1 = reinterpret_cast< wxImage * >(argp1);
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 resultobj = result;
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj = 0;
16221 wxImage *arg1 = (wxImage *) 0 ;
16222 buffer arg2 ;
16223 int arg3 ;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 Py_ssize_t temp2 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 char * kwnames[] = {
16230 (char *) "self",(char *) "alpha", NULL
16231 };
16232
16233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16235 if (!SWIG_IsOK(res1)) {
16236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16237 }
16238 arg1 = reinterpret_cast< wxImage * >(argp1);
16239 {
16240 if (obj1 != Py_None) {
16241 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16242 arg3 = (int)temp2;
16243 }
16244 }
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16248 wxPyEndAllowThreads(__tstate);
16249 if (PyErr_Occurred()) SWIG_fail;
16250 }
16251 resultobj = SWIG_Py_Void();
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj = 0;
16260 wxImage *arg1 = (wxImage *) 0 ;
16261 byte arg2 ;
16262 byte arg3 ;
16263 byte arg4 ;
16264 void *argp1 = 0 ;
16265 int res1 = 0 ;
16266 unsigned char val2 ;
16267 int ecode2 = 0 ;
16268 unsigned char val3 ;
16269 int ecode3 = 0 ;
16270 unsigned char val4 ;
16271 int ecode4 = 0 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 PyObject * obj2 = 0 ;
16275 PyObject * obj3 = 0 ;
16276 char * kwnames[] = {
16277 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16278 };
16279
16280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16284 }
16285 arg1 = reinterpret_cast< wxImage * >(argp1);
16286 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16287 if (!SWIG_IsOK(ecode2)) {
16288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16289 }
16290 arg2 = static_cast< byte >(val2);
16291 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16292 if (!SWIG_IsOK(ecode3)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16294 }
16295 arg3 = static_cast< byte >(val3);
16296 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16297 if (!SWIG_IsOK(ecode4)) {
16298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16299 }
16300 arg4 = static_cast< byte >(val4);
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 (arg1)->SetMaskColour(arg2,arg3,arg4);
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 resultobj = SWIG_Py_Void();
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 wxImage *arg1 = (wxImage *) 0 ;
16317 byte *arg2 = (byte *) 0 ;
16318 byte *arg3 = (byte *) 0 ;
16319 byte *arg4 = (byte *) 0 ;
16320 void *argp1 = 0 ;
16321 int res1 = 0 ;
16322 byte temp2 ;
16323 int res2 = SWIG_TMPOBJ ;
16324 byte temp3 ;
16325 int res3 = SWIG_TMPOBJ ;
16326 byte temp4 ;
16327 int res4 = SWIG_TMPOBJ ;
16328 PyObject *swig_obj[1] ;
16329
16330 arg2 = &temp2;
16331 arg3 = &temp3;
16332 arg4 = &temp4;
16333 if (!args) SWIG_fail;
16334 swig_obj[0] = args;
16335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16338 }
16339 arg1 = reinterpret_cast< wxImage * >(argp1);
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 resultobj = SWIG_Py_Void();
16347 if (SWIG_IsTmpObj(res2)) {
16348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16349 } else {
16350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16352 }
16353 if (SWIG_IsTmpObj(res3)) {
16354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16355 } else {
16356 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16358 }
16359 if (SWIG_IsTmpObj(res4)) {
16360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16361 } else {
16362 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16364 }
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 byte result;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 PyObject *swig_obj[1] ;
16378
16379 if (!args) SWIG_fail;
16380 swig_obj[0] = args;
16381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16384 }
16385 arg1 = reinterpret_cast< wxImage * >(argp1);
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 result = (byte)(arg1)->GetMaskRed();
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16400 PyObject *resultobj = 0;
16401 wxImage *arg1 = (wxImage *) 0 ;
16402 byte result;
16403 void *argp1 = 0 ;
16404 int res1 = 0 ;
16405 PyObject *swig_obj[1] ;
16406
16407 if (!args) SWIG_fail;
16408 swig_obj[0] = args;
16409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16412 }
16413 arg1 = reinterpret_cast< wxImage * >(argp1);
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 result = (byte)(arg1)->GetMaskGreen();
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16428 PyObject *resultobj = 0;
16429 wxImage *arg1 = (wxImage *) 0 ;
16430 byte result;
16431 void *argp1 = 0 ;
16432 int res1 = 0 ;
16433 PyObject *swig_obj[1] ;
16434
16435 if (!args) SWIG_fail;
16436 swig_obj[0] = args;
16437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16438 if (!SWIG_IsOK(res1)) {
16439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16440 }
16441 arg1 = reinterpret_cast< wxImage * >(argp1);
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (byte)(arg1)->GetMaskBlue();
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16449 return resultobj;
16450 fail:
16451 return NULL;
16452 }
16453
16454
16455 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16456 PyObject *resultobj = 0;
16457 wxImage *arg1 = (wxImage *) 0 ;
16458 bool arg2 = (bool) true ;
16459 void *argp1 = 0 ;
16460 int res1 = 0 ;
16461 bool val2 ;
16462 int ecode2 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 char * kwnames[] = {
16466 (char *) "self",(char *) "mask", NULL
16467 };
16468
16469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16471 if (!SWIG_IsOK(res1)) {
16472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16473 }
16474 arg1 = reinterpret_cast< wxImage * >(argp1);
16475 if (obj1) {
16476 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16477 if (!SWIG_IsOK(ecode2)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16479 }
16480 arg2 = static_cast< bool >(val2);
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 (arg1)->SetMask(arg2);
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 resultobj = SWIG_Py_Void();
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16496 PyObject *resultobj = 0;
16497 wxImage *arg1 = (wxImage *) 0 ;
16498 bool result;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 PyObject *swig_obj[1] ;
16502
16503 if (!args) SWIG_fail;
16504 swig_obj[0] = args;
16505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16508 }
16509 arg1 = reinterpret_cast< wxImage * >(argp1);
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)(arg1)->HasMask();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxImage *arg1 = (wxImage *) 0 ;
16528 double arg2 ;
16529 wxPoint *arg3 = 0 ;
16530 bool arg4 = (bool) true ;
16531 wxPoint *arg5 = (wxPoint *) NULL ;
16532 SwigValueWrapper<wxImage > result;
16533 void *argp1 = 0 ;
16534 int res1 = 0 ;
16535 double val2 ;
16536 int ecode2 = 0 ;
16537 wxPoint temp3 ;
16538 bool val4 ;
16539 int ecode4 = 0 ;
16540 void *argp5 = 0 ;
16541 int res5 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 PyObject * obj2 = 0 ;
16545 PyObject * obj3 = 0 ;
16546 PyObject * obj4 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16555 }
16556 arg1 = reinterpret_cast< wxImage * >(argp1);
16557 ecode2 = SWIG_AsVal_double(obj1, &val2);
16558 if (!SWIG_IsOK(ecode2)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16560 }
16561 arg2 = static_cast< double >(val2);
16562 {
16563 arg3 = &temp3;
16564 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16565 }
16566 if (obj3) {
16567 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16568 if (!SWIG_IsOK(ecode4)) {
16569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16570 }
16571 arg4 = static_cast< bool >(val4);
16572 }
16573 if (obj4) {
16574 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16575 if (!SWIG_IsOK(res5)) {
16576 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16577 }
16578 arg5 = reinterpret_cast< wxPoint * >(argp5);
16579 }
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16583 wxPyEndAllowThreads(__tstate);
16584 if (PyErr_Occurred()) SWIG_fail;
16585 }
16586 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj = 0;
16595 wxImage *arg1 = (wxImage *) 0 ;
16596 bool arg2 = (bool) true ;
16597 SwigValueWrapper<wxImage > result;
16598 void *argp1 = 0 ;
16599 int res1 = 0 ;
16600 bool val2 ;
16601 int ecode2 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 char * kwnames[] = {
16605 (char *) "self",(char *) "clockwise", NULL
16606 };
16607
16608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16610 if (!SWIG_IsOK(res1)) {
16611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16612 }
16613 arg1 = reinterpret_cast< wxImage * >(argp1);
16614 if (obj1) {
16615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16616 if (!SWIG_IsOK(ecode2)) {
16617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16618 }
16619 arg2 = static_cast< bool >(val2);
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (arg1)->Rotate90(arg2);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 bool arg2 = (bool) true ;
16638 SwigValueWrapper<wxImage > result;
16639 void *argp1 = 0 ;
16640 int res1 = 0 ;
16641 bool val2 ;
16642 int ecode2 = 0 ;
16643 PyObject * obj0 = 0 ;
16644 PyObject * obj1 = 0 ;
16645 char * kwnames[] = {
16646 (char *) "self",(char *) "horizontally", NULL
16647 };
16648
16649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16651 if (!SWIG_IsOK(res1)) {
16652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16653 }
16654 arg1 = reinterpret_cast< wxImage * >(argp1);
16655 if (obj1) {
16656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16657 if (!SWIG_IsOK(ecode2)) {
16658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16659 }
16660 arg2 = static_cast< bool >(val2);
16661 }
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (arg1)->Mirror(arg2);
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj = 0;
16677 wxImage *arg1 = (wxImage *) 0 ;
16678 byte arg2 ;
16679 byte arg3 ;
16680 byte arg4 ;
16681 byte arg5 ;
16682 byte arg6 ;
16683 byte arg7 ;
16684 void *argp1 = 0 ;
16685 int res1 = 0 ;
16686 unsigned char val2 ;
16687 int ecode2 = 0 ;
16688 unsigned char val3 ;
16689 int ecode3 = 0 ;
16690 unsigned char val4 ;
16691 int ecode4 = 0 ;
16692 unsigned char val5 ;
16693 int ecode5 = 0 ;
16694 unsigned char val6 ;
16695 int ecode6 = 0 ;
16696 unsigned char val7 ;
16697 int ecode7 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 PyObject * obj1 = 0 ;
16700 PyObject * obj2 = 0 ;
16701 PyObject * obj3 = 0 ;
16702 PyObject * obj4 = 0 ;
16703 PyObject * obj5 = 0 ;
16704 PyObject * obj6 = 0 ;
16705 char * kwnames[] = {
16706 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16707 };
16708
16709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16711 if (!SWIG_IsOK(res1)) {
16712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16713 }
16714 arg1 = reinterpret_cast< wxImage * >(argp1);
16715 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16716 if (!SWIG_IsOK(ecode2)) {
16717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16718 }
16719 arg2 = static_cast< byte >(val2);
16720 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16721 if (!SWIG_IsOK(ecode3)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16723 }
16724 arg3 = static_cast< byte >(val3);
16725 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16726 if (!SWIG_IsOK(ecode4)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16728 }
16729 arg4 = static_cast< byte >(val4);
16730 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16731 if (!SWIG_IsOK(ecode5)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16733 }
16734 arg5 = static_cast< byte >(val5);
16735 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16736 if (!SWIG_IsOK(ecode6)) {
16737 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16738 }
16739 arg6 = static_cast< byte >(val6);
16740 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16741 if (!SWIG_IsOK(ecode7)) {
16742 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16743 }
16744 arg7 = static_cast< byte >(val7);
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16748 wxPyEndAllowThreads(__tstate);
16749 if (PyErr_Occurred()) SWIG_fail;
16750 }
16751 resultobj = SWIG_Py_Void();
16752 return resultobj;
16753 fail:
16754 return NULL;
16755 }
16756
16757
16758 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16759 PyObject *resultobj = 0;
16760 wxImage *arg1 = (wxImage *) 0 ;
16761 double arg2 = (double) 0.299 ;
16762 double arg3 = (double) 0.587 ;
16763 double arg4 = (double) 0.114 ;
16764 SwigValueWrapper<wxImage > result;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 double val2 ;
16768 int ecode2 = 0 ;
16769 double val3 ;
16770 int ecode3 = 0 ;
16771 double val4 ;
16772 int ecode4 = 0 ;
16773 PyObject * obj0 = 0 ;
16774 PyObject * obj1 = 0 ;
16775 PyObject * obj2 = 0 ;
16776 PyObject * obj3 = 0 ;
16777 char * kwnames[] = {
16778 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16779 };
16780
16781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16783 if (!SWIG_IsOK(res1)) {
16784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16785 }
16786 arg1 = reinterpret_cast< wxImage * >(argp1);
16787 if (obj1) {
16788 ecode2 = SWIG_AsVal_double(obj1, &val2);
16789 if (!SWIG_IsOK(ecode2)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16791 }
16792 arg2 = static_cast< double >(val2);
16793 }
16794 if (obj2) {
16795 ecode3 = SWIG_AsVal_double(obj2, &val3);
16796 if (!SWIG_IsOK(ecode3)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16798 }
16799 arg3 = static_cast< double >(val3);
16800 }
16801 if (obj3) {
16802 ecode4 = SWIG_AsVal_double(obj3, &val4);
16803 if (!SWIG_IsOK(ecode4)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16805 }
16806 arg4 = static_cast< double >(val4);
16807 }
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16822 PyObject *resultobj = 0;
16823 wxImage *arg1 = (wxImage *) 0 ;
16824 byte arg2 ;
16825 byte arg3 ;
16826 byte arg4 ;
16827 SwigValueWrapper<wxImage > result;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 unsigned char val2 ;
16831 int ecode2 = 0 ;
16832 unsigned char val3 ;
16833 int ecode3 = 0 ;
16834 unsigned char val4 ;
16835 int ecode4 = 0 ;
16836 PyObject * obj0 = 0 ;
16837 PyObject * obj1 = 0 ;
16838 PyObject * obj2 = 0 ;
16839 PyObject * obj3 = 0 ;
16840 char * kwnames[] = {
16841 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16842 };
16843
16844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16846 if (!SWIG_IsOK(res1)) {
16847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16848 }
16849 arg1 = reinterpret_cast< wxImage * >(argp1);
16850 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16851 if (!SWIG_IsOK(ecode2)) {
16852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16853 }
16854 arg2 = static_cast< byte >(val2);
16855 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16856 if (!SWIG_IsOK(ecode3)) {
16857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16858 }
16859 arg3 = static_cast< byte >(val3);
16860 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16861 if (!SWIG_IsOK(ecode4)) {
16862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16863 }
16864 arg4 = static_cast< byte >(val4);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImage *arg1 = (wxImage *) 0 ;
16881 wxString *arg2 = 0 ;
16882 wxString *arg3 = 0 ;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 bool temp2 = false ;
16886 bool temp3 = false ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 PyObject * obj2 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "self",(char *) "name",(char *) "value", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16898 }
16899 arg1 = reinterpret_cast< wxImage * >(argp1);
16900 {
16901 arg2 = wxString_in_helper(obj1);
16902 if (arg2 == NULL) SWIG_fail;
16903 temp2 = true;
16904 }
16905 {
16906 arg3 = wxString_in_helper(obj2);
16907 if (arg3 == NULL) SWIG_fail;
16908 temp3 = true;
16909 }
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 resultobj = SWIG_Py_Void();
16917 {
16918 if (temp2)
16919 delete arg2;
16920 }
16921 {
16922 if (temp3)
16923 delete arg3;
16924 }
16925 return resultobj;
16926 fail:
16927 {
16928 if (temp2)
16929 delete arg2;
16930 }
16931 {
16932 if (temp3)
16933 delete arg3;
16934 }
16935 return NULL;
16936 }
16937
16938
16939 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj = 0;
16941 wxImage *arg1 = (wxImage *) 0 ;
16942 wxString *arg2 = 0 ;
16943 int arg3 ;
16944 void *argp1 = 0 ;
16945 int res1 = 0 ;
16946 bool temp2 = false ;
16947 int val3 ;
16948 int ecode3 = 0 ;
16949 PyObject * obj0 = 0 ;
16950 PyObject * obj1 = 0 ;
16951 PyObject * obj2 = 0 ;
16952 char * kwnames[] = {
16953 (char *) "self",(char *) "name",(char *) "value", NULL
16954 };
16955
16956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16960 }
16961 arg1 = reinterpret_cast< wxImage * >(argp1);
16962 {
16963 arg2 = wxString_in_helper(obj1);
16964 if (arg2 == NULL) SWIG_fail;
16965 temp2 = true;
16966 }
16967 ecode3 = SWIG_AsVal_int(obj2, &val3);
16968 if (!SWIG_IsOK(ecode3)) {
16969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16970 }
16971 arg3 = static_cast< int >(val3);
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 (arg1)->SetOption((wxString const &)*arg2,arg3);
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 resultobj = SWIG_Py_Void();
16979 {
16980 if (temp2)
16981 delete arg2;
16982 }
16983 return resultobj;
16984 fail:
16985 {
16986 if (temp2)
16987 delete arg2;
16988 }
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 wxImage *arg1 = (wxImage *) 0 ;
16996 wxString *arg2 = 0 ;
16997 wxString result;
16998 void *argp1 = 0 ;
16999 int res1 = 0 ;
17000 bool temp2 = false ;
17001 PyObject * obj0 = 0 ;
17002 PyObject * obj1 = 0 ;
17003 char * kwnames[] = {
17004 (char *) "self",(char *) "name", NULL
17005 };
17006
17007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17009 if (!SWIG_IsOK(res1)) {
17010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17011 }
17012 arg1 = reinterpret_cast< wxImage * >(argp1);
17013 {
17014 arg2 = wxString_in_helper(obj1);
17015 if (arg2 == NULL) SWIG_fail;
17016 temp2 = true;
17017 }
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 {
17025 #if wxUSE_UNICODE
17026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17027 #else
17028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17029 #endif
17030 }
17031 {
17032 if (temp2)
17033 delete arg2;
17034 }
17035 return resultobj;
17036 fail:
17037 {
17038 if (temp2)
17039 delete arg2;
17040 }
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj = 0;
17047 wxImage *arg1 = (wxImage *) 0 ;
17048 wxString *arg2 = 0 ;
17049 int result;
17050 void *argp1 = 0 ;
17051 int res1 = 0 ;
17052 bool temp2 = false ;
17053 PyObject * obj0 = 0 ;
17054 PyObject * obj1 = 0 ;
17055 char * kwnames[] = {
17056 (char *) "self",(char *) "name", NULL
17057 };
17058
17059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17063 }
17064 arg1 = reinterpret_cast< wxImage * >(argp1);
17065 {
17066 arg2 = wxString_in_helper(obj1);
17067 if (arg2 == NULL) SWIG_fail;
17068 temp2 = true;
17069 }
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 resultobj = SWIG_From_int(static_cast< int >(result));
17077 {
17078 if (temp2)
17079 delete arg2;
17080 }
17081 return resultobj;
17082 fail:
17083 {
17084 if (temp2)
17085 delete arg2;
17086 }
17087 return NULL;
17088 }
17089
17090
17091 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17092 PyObject *resultobj = 0;
17093 wxImage *arg1 = (wxImage *) 0 ;
17094 wxString *arg2 = 0 ;
17095 bool result;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 bool temp2 = false ;
17099 PyObject * obj0 = 0 ;
17100 PyObject * obj1 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "name", NULL
17103 };
17104
17105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17107 if (!SWIG_IsOK(res1)) {
17108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17109 }
17110 arg1 = reinterpret_cast< wxImage * >(argp1);
17111 {
17112 arg2 = wxString_in_helper(obj1);
17113 if (arg2 == NULL) SWIG_fail;
17114 temp2 = true;
17115 }
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 {
17123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17124 }
17125 {
17126 if (temp2)
17127 delete arg2;
17128 }
17129 return resultobj;
17130 fail:
17131 {
17132 if (temp2)
17133 delete arg2;
17134 }
17135 return NULL;
17136 }
17137
17138
17139 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj = 0;
17141 wxImage *arg1 = (wxImage *) 0 ;
17142 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17143 unsigned long result;
17144 void *argp1 = 0 ;
17145 int res1 = 0 ;
17146 unsigned long val2 ;
17147 int ecode2 = 0 ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 char * kwnames[] = {
17151 (char *) "self",(char *) "stopafter", NULL
17152 };
17153
17154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17156 if (!SWIG_IsOK(res1)) {
17157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17158 }
17159 arg1 = reinterpret_cast< wxImage * >(argp1);
17160 if (obj1) {
17161 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17162 if (!SWIG_IsOK(ecode2)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17164 }
17165 arg2 = static_cast< unsigned long >(val2);
17166 }
17167 {
17168 PyThreadState* __tstate = wxPyBeginAllowThreads();
17169 result = (unsigned long)(arg1)->CountColours(arg2);
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17174 return resultobj;
17175 fail:
17176 return NULL;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17181 PyObject *resultobj = 0;
17182 wxImage *arg1 = (wxImage *) 0 ;
17183 wxImageHistogram *arg2 = 0 ;
17184 unsigned long result;
17185 void *argp1 = 0 ;
17186 int res1 = 0 ;
17187 void *argp2 = 0 ;
17188 int res2 = 0 ;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 char * kwnames[] = {
17192 (char *) "self",(char *) "h", NULL
17193 };
17194
17195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17197 if (!SWIG_IsOK(res1)) {
17198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17199 }
17200 arg1 = reinterpret_cast< wxImage * >(argp1);
17201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17202 if (!SWIG_IsOK(res2)) {
17203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17204 }
17205 if (!argp2) {
17206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17207 }
17208 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj = 0;
17224 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17225 void *argp1 = 0 ;
17226 int res1 = 0 ;
17227 PyObject * obj0 = 0 ;
17228 char * kwnames[] = {
17229 (char *) "handler", NULL
17230 };
17231
17232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17234 if (!SWIG_IsOK(res1)) {
17235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17236 }
17237 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 wxImage::AddHandler(arg1);
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 resultobj = SWIG_Py_Void();
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj = 0;
17253 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17254 void *argp1 = 0 ;
17255 int res1 = 0 ;
17256 PyObject * obj0 = 0 ;
17257 char * kwnames[] = {
17258 (char *) "handler", NULL
17259 };
17260
17261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17263 if (!SWIG_IsOK(res1)) {
17264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17265 }
17266 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 wxImage::InsertHandler(arg1);
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 resultobj = SWIG_Py_Void();
17274 return resultobj;
17275 fail:
17276 return NULL;
17277 }
17278
17279
17280 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17281 PyObject *resultobj = 0;
17282 wxString *arg1 = 0 ;
17283 bool result;
17284 bool temp1 = false ;
17285 PyObject * obj0 = 0 ;
17286 char * kwnames[] = {
17287 (char *) "name", NULL
17288 };
17289
17290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17291 {
17292 arg1 = wxString_in_helper(obj0);
17293 if (arg1 == NULL) SWIG_fail;
17294 temp1 = true;
17295 }
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 {
17303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17304 }
17305 {
17306 if (temp1)
17307 delete arg1;
17308 }
17309 return resultobj;
17310 fail:
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 PyObject *resultobj = 0;
17321 PyObject *result = 0 ;
17322
17323 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (PyObject *)wxImage_GetHandlers();
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 resultobj = result;
17331 return resultobj;
17332 fail:
17333 return NULL;
17334 }
17335
17336
17337 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17338 PyObject *resultobj = 0;
17339 wxString result;
17340
17341 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = wxImage::GetImageExtWildcard();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 #if wxUSE_UNICODE
17350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17351 #else
17352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17353 #endif
17354 }
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj = 0;
17363 wxImage *arg1 = (wxImage *) 0 ;
17364 int arg2 = (int) -1 ;
17365 wxBitmap result;
17366 void *argp1 = 0 ;
17367 int res1 = 0 ;
17368 int val2 ;
17369 int ecode2 = 0 ;
17370 PyObject * obj0 = 0 ;
17371 PyObject * obj1 = 0 ;
17372 char * kwnames[] = {
17373 (char *) "self",(char *) "depth", NULL
17374 };
17375
17376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17378 if (!SWIG_IsOK(res1)) {
17379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17380 }
17381 arg1 = reinterpret_cast< wxImage * >(argp1);
17382 if (obj1) {
17383 ecode2 = SWIG_AsVal_int(obj1, &val2);
17384 if (!SWIG_IsOK(ecode2)) {
17385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17386 }
17387 arg2 = static_cast< int >(val2);
17388 }
17389 {
17390 if (!wxPyCheckForApp()) SWIG_fail;
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = wxImage_ConvertToBitmap(arg1,arg2);
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj = 0;
17405 wxImage *arg1 = (wxImage *) 0 ;
17406 byte arg2 ;
17407 byte arg3 ;
17408 byte arg4 ;
17409 wxBitmap result;
17410 void *argp1 = 0 ;
17411 int res1 = 0 ;
17412 unsigned char val2 ;
17413 int ecode2 = 0 ;
17414 unsigned char val3 ;
17415 int ecode3 = 0 ;
17416 unsigned char val4 ;
17417 int ecode4 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 PyObject * obj3 = 0 ;
17422 char * kwnames[] = {
17423 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17424 };
17425
17426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17430 }
17431 arg1 = reinterpret_cast< wxImage * >(argp1);
17432 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17433 if (!SWIG_IsOK(ecode2)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17435 }
17436 arg2 = static_cast< byte >(val2);
17437 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17438 if (!SWIG_IsOK(ecode3)) {
17439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17440 }
17441 arg3 = static_cast< byte >(val3);
17442 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17443 if (!SWIG_IsOK(ecode4)) {
17444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17445 }
17446 arg4 = static_cast< byte >(val4);
17447 {
17448 if (!wxPyCheckForApp()) SWIG_fail;
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17462 PyObject *resultobj = 0;
17463 wxImage *arg1 = (wxImage *) 0 ;
17464 double arg2 ;
17465 void *argp1 = 0 ;
17466 int res1 = 0 ;
17467 double val2 ;
17468 int ecode2 = 0 ;
17469 PyObject * obj0 = 0 ;
17470 PyObject * obj1 = 0 ;
17471 char * kwnames[] = {
17472 (char *) "self",(char *) "angle", NULL
17473 };
17474
17475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17477 if (!SWIG_IsOK(res1)) {
17478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17479 }
17480 arg1 = reinterpret_cast< wxImage * >(argp1);
17481 ecode2 = SWIG_AsVal_double(obj1, &val2);
17482 if (!SWIG_IsOK(ecode2)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17484 }
17485 arg2 = static_cast< double >(val2);
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 (arg1)->RotateHue(arg2);
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_Py_Void();
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxImage_RGBValue arg1 ;
17502 wxImage_HSVValue result;
17503 void *argp1 ;
17504 int res1 = 0 ;
17505 PyObject * obj0 = 0 ;
17506 char * kwnames[] = {
17507 (char *) "rgb", NULL
17508 };
17509
17510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17511 {
17512 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17513 if (!SWIG_IsOK(res1)) {
17514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17515 }
17516 if (!argp1) {
17517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17518 } else {
17519 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17520 arg1 = *temp;
17521 if (SWIG_IsNewObj(res1)) delete temp;
17522 }
17523 }
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = wxImage::RGBtoHSV(arg1);
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj = 0;
17539 wxImage_HSVValue arg1 ;
17540 wxImage_RGBValue result;
17541 void *argp1 ;
17542 int res1 = 0 ;
17543 PyObject * obj0 = 0 ;
17544 char * kwnames[] = {
17545 (char *) "hsv", NULL
17546 };
17547
17548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17549 {
17550 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17551 if (!SWIG_IsOK(res1)) {
17552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17553 }
17554 if (!argp1) {
17555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17556 } else {
17557 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17558 arg1 = *temp;
17559 if (SWIG_IsNewObj(res1)) delete temp;
17560 }
17561 }
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = wxImage::HSVtoRGB(arg1);
17565 wxPyEndAllowThreads(__tstate);
17566 if (PyErr_Occurred()) SWIG_fail;
17567 }
17568 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17569 return resultobj;
17570 fail:
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17576 PyObject *obj;
17577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17578 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17579 return SWIG_Py_Void();
17580 }
17581
17582 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17583 return SWIG_Python_InitShadowInstance(args);
17584 }
17585
17586 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj = 0;
17588 int arg1 ;
17589 int arg2 ;
17590 buffer arg3 ;
17591 int arg4 ;
17592 buffer arg5 = (buffer) NULL ;
17593 int arg6 = (int) 0 ;
17594 wxImage *result = 0 ;
17595 int val1 ;
17596 int ecode1 = 0 ;
17597 int val2 ;
17598 int ecode2 = 0 ;
17599 Py_ssize_t temp3 ;
17600 Py_ssize_t temp5 ;
17601 PyObject * obj0 = 0 ;
17602 PyObject * obj1 = 0 ;
17603 PyObject * obj2 = 0 ;
17604 PyObject * obj3 = 0 ;
17605 char * kwnames[] = {
17606 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17607 };
17608
17609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17610 ecode1 = SWIG_AsVal_int(obj0, &val1);
17611 if (!SWIG_IsOK(ecode1)) {
17612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17613 }
17614 arg1 = static_cast< int >(val1);
17615 ecode2 = SWIG_AsVal_int(obj1, &val2);
17616 if (!SWIG_IsOK(ecode2)) {
17617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17618 }
17619 arg2 = static_cast< int >(val2);
17620 {
17621 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17622 arg4 = (int)temp3;
17623 }
17624 if (obj3) {
17625 {
17626 if (obj3 != Py_None) {
17627 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17628 arg6 = (int)temp5;
17629 }
17630 }
17631 }
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 {
17639 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17640 }
17641 return resultobj;
17642 fail:
17643 return NULL;
17644 }
17645
17646
17647 SWIGINTERN int NullImage_set(PyObject *) {
17648 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17649 return 1;
17650 }
17651
17652
17653 SWIGINTERN PyObject *NullImage_get(void) {
17654 PyObject *pyobj = 0;
17655
17656 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17657 return pyobj;
17658 }
17659
17660
17661 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17662 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17663 return 1;
17664 }
17665
17666
17667 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17668 PyObject *pyobj = 0;
17669
17670 {
17671 #if wxUSE_UNICODE
17672 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17673 #else
17674 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17675 #endif
17676 }
17677 return pyobj;
17678 }
17679
17680
17681 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17682 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17683 return 1;
17684 }
17685
17686
17687 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17688 PyObject *pyobj = 0;
17689
17690 {
17691 #if wxUSE_UNICODE
17692 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17693 #else
17694 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17695 #endif
17696 }
17697 return pyobj;
17698 }
17699
17700
17701 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17702 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17703 return 1;
17704 }
17705
17706
17707 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17708 PyObject *pyobj = 0;
17709
17710 {
17711 #if wxUSE_UNICODE
17712 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17713 #else
17714 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17715 #endif
17716 }
17717 return pyobj;
17718 }
17719
17720
17721 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17722 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17723 return 1;
17724 }
17725
17726
17727 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17728 PyObject *pyobj = 0;
17729
17730 {
17731 #if wxUSE_UNICODE
17732 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17733 #else
17734 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17735 #endif
17736 }
17737 return pyobj;
17738 }
17739
17740
17741 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17742 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17743 return 1;
17744 }
17745
17746
17747 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17748 PyObject *pyobj = 0;
17749
17750 {
17751 #if wxUSE_UNICODE
17752 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17753 #else
17754 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17755 #endif
17756 }
17757 return pyobj;
17758 }
17759
17760
17761 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17762 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17763 return 1;
17764 }
17765
17766
17767 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17768 PyObject *pyobj = 0;
17769
17770 {
17771 #if wxUSE_UNICODE
17772 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17773 #else
17774 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17775 #endif
17776 }
17777 return pyobj;
17778 }
17779
17780
17781 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17782 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17783 return 1;
17784 }
17785
17786
17787 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17788 PyObject *pyobj = 0;
17789
17790 {
17791 #if wxUSE_UNICODE
17792 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17793 #else
17794 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17795 #endif
17796 }
17797 return pyobj;
17798 }
17799
17800
17801 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17802 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17803 return 1;
17804 }
17805
17806
17807 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17808 PyObject *pyobj = 0;
17809
17810 {
17811 #if wxUSE_UNICODE
17812 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17813 #else
17814 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17815 #endif
17816 }
17817 return pyobj;
17818 }
17819
17820
17821 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17822 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17823 return 1;
17824 }
17825
17826
17827 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17828 PyObject *pyobj = 0;
17829
17830 {
17831 #if wxUSE_UNICODE
17832 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17833 #else
17834 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17835 #endif
17836 }
17837 return pyobj;
17838 }
17839
17840
17841 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17842 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17843 return 1;
17844 }
17845
17846
17847 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17848 PyObject *pyobj = 0;
17849
17850 {
17851 #if wxUSE_UNICODE
17852 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17853 #else
17854 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17855 #endif
17856 }
17857 return pyobj;
17858 }
17859
17860
17861 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17862 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17863 return 1;
17864 }
17865
17866
17867 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17868 PyObject *pyobj = 0;
17869
17870 {
17871 #if wxUSE_UNICODE
17872 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17873 #else
17874 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17875 #endif
17876 }
17877 return pyobj;
17878 }
17879
17880
17881 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17882 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17883 return 1;
17884 }
17885
17886
17887 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17888 PyObject *pyobj = 0;
17889
17890 {
17891 #if wxUSE_UNICODE
17892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17893 #else
17894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17895 #endif
17896 }
17897 return pyobj;
17898 }
17899
17900
17901 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17902 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17903 return 1;
17904 }
17905
17906
17907 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17908 PyObject *pyobj = 0;
17909
17910 {
17911 #if wxUSE_UNICODE
17912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17913 #else
17914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17915 #endif
17916 }
17917 return pyobj;
17918 }
17919
17920
17921 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17922 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17923 return 1;
17924 }
17925
17926
17927 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17928 PyObject *pyobj = 0;
17929
17930 {
17931 #if wxUSE_UNICODE
17932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17933 #else
17934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17935 #endif
17936 }
17937 return pyobj;
17938 }
17939
17940
17941 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17943 return 1;
17944 }
17945
17946
17947 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17948 PyObject *pyobj = 0;
17949
17950 {
17951 #if wxUSE_UNICODE
17952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17953 #else
17954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17955 #endif
17956 }
17957 return pyobj;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17962 PyObject *resultobj = 0;
17963 wxBMPHandler *result = 0 ;
17964
17965 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 result = (wxBMPHandler *)new wxBMPHandler();
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *obj;
17981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17982 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17983 return SWIG_Py_Void();
17984 }
17985
17986 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 return SWIG_Python_InitShadowInstance(args);
17988 }
17989
17990 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 PyObject *resultobj = 0;
17992 wxICOHandler *result = 0 ;
17993
17994 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 result = (wxICOHandler *)new wxICOHandler();
17998 wxPyEndAllowThreads(__tstate);
17999 if (PyErr_Occurred()) SWIG_fail;
18000 }
18001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 PyObject *obj;
18010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18011 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18012 return SWIG_Py_Void();
18013 }
18014
18015 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18016 return SWIG_Python_InitShadowInstance(args);
18017 }
18018
18019 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18020 PyObject *resultobj = 0;
18021 wxCURHandler *result = 0 ;
18022
18023 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (wxCURHandler *)new wxCURHandler();
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *obj;
18039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18040 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18041 return SWIG_Py_Void();
18042 }
18043
18044 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18045 return SWIG_Python_InitShadowInstance(args);
18046 }
18047
18048 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18049 PyObject *resultobj = 0;
18050 wxANIHandler *result = 0 ;
18051
18052 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = (wxANIHandler *)new wxANIHandler();
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18067 PyObject *obj;
18068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18069 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18070 return SWIG_Py_Void();
18071 }
18072
18073 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074 return SWIG_Python_InitShadowInstance(args);
18075 }
18076
18077 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 PyObject *resultobj = 0;
18079 wxPNGHandler *result = 0 ;
18080
18081 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (wxPNGHandler *)new wxPNGHandler();
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096 PyObject *obj;
18097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18098 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18099 return SWIG_Py_Void();
18100 }
18101
18102 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18103 return SWIG_Python_InitShadowInstance(args);
18104 }
18105
18106 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18107 PyObject *resultobj = 0;
18108 wxGIFHandler *result = 0 ;
18109
18110 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 result = (wxGIFHandler *)new wxGIFHandler();
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18125 PyObject *obj;
18126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18127 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18128 return SWIG_Py_Void();
18129 }
18130
18131 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 return SWIG_Python_InitShadowInstance(args);
18133 }
18134
18135 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxPCXHandler *result = 0 ;
18138
18139 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (wxPCXHandler *)new wxPCXHandler();
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *obj;
18155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18156 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18157 return SWIG_Py_Void();
18158 }
18159
18160 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18161 return SWIG_Python_InitShadowInstance(args);
18162 }
18163
18164 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18165 PyObject *resultobj = 0;
18166 wxJPEGHandler *result = 0 ;
18167
18168 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (wxJPEGHandler *)new wxJPEGHandler();
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *obj;
18184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18185 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18186 return SWIG_Py_Void();
18187 }
18188
18189 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18190 return SWIG_Python_InitShadowInstance(args);
18191 }
18192
18193 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18194 PyObject *resultobj = 0;
18195 wxPNMHandler *result = 0 ;
18196
18197 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (wxPNMHandler *)new wxPNMHandler();
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *obj;
18213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18214 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18215 return SWIG_Py_Void();
18216 }
18217
18218 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 return SWIG_Python_InitShadowInstance(args);
18220 }
18221
18222 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18223 PyObject *resultobj = 0;
18224 wxXPMHandler *result = 0 ;
18225
18226 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = (wxXPMHandler *)new wxXPMHandler();
18230 wxPyEndAllowThreads(__tstate);
18231 if (PyErr_Occurred()) SWIG_fail;
18232 }
18233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18234 return resultobj;
18235 fail:
18236 return NULL;
18237 }
18238
18239
18240 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18241 PyObject *obj;
18242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18243 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18244 return SWIG_Py_Void();
18245 }
18246
18247 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 return SWIG_Python_InitShadowInstance(args);
18249 }
18250
18251 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18252 PyObject *resultobj = 0;
18253 wxTIFFHandler *result = 0 ;
18254
18255 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18256 {
18257 PyThreadState* __tstate = wxPyBeginAllowThreads();
18258 result = (wxTIFFHandler *)new wxTIFFHandler();
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18270 PyObject *obj;
18271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18272 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18273 return SWIG_Py_Void();
18274 }
18275
18276 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 return SWIG_Python_InitShadowInstance(args);
18278 }
18279
18280 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj = 0;
18282 wxImage *arg1 = 0 ;
18283 wxImage *arg2 = 0 ;
18284 int arg3 = (int) 236 ;
18285 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18286 bool result;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 void *argp2 = 0 ;
18290 int res2 = 0 ;
18291 int val3 ;
18292 int ecode3 = 0 ;
18293 int val4 ;
18294 int ecode4 = 0 ;
18295 PyObject * obj0 = 0 ;
18296 PyObject * obj1 = 0 ;
18297 PyObject * obj2 = 0 ;
18298 PyObject * obj3 = 0 ;
18299 char * kwnames[] = {
18300 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18301 };
18302
18303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18304 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18307 }
18308 if (!argp1) {
18309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18310 }
18311 arg1 = reinterpret_cast< wxImage * >(argp1);
18312 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18313 if (!SWIG_IsOK(res2)) {
18314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18315 }
18316 if (!argp2) {
18317 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18318 }
18319 arg2 = reinterpret_cast< wxImage * >(argp2);
18320 if (obj2) {
18321 ecode3 = SWIG_AsVal_int(obj2, &val3);
18322 if (!SWIG_IsOK(ecode3)) {
18323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18324 }
18325 arg3 = static_cast< int >(val3);
18326 }
18327 if (obj3) {
18328 ecode4 = SWIG_AsVal_int(obj3, &val4);
18329 if (!SWIG_IsOK(ecode4)) {
18330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18331 }
18332 arg4 = static_cast< int >(val4);
18333 }
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 {
18341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18342 }
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18350 PyObject *obj;
18351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18352 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18353 return SWIG_Py_Void();
18354 }
18355
18356 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18357 PyObject *resultobj = 0;
18358 wxEvtHandler *result = 0 ;
18359
18360 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (wxEvtHandler *)new wxEvtHandler();
18364 wxPyEndAllowThreads(__tstate);
18365 if (PyErr_Occurred()) SWIG_fail;
18366 }
18367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18368 return resultobj;
18369 fail:
18370 return NULL;
18371 }
18372
18373
18374 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18375 PyObject *resultobj = 0;
18376 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18377 wxEvtHandler *result = 0 ;
18378 void *argp1 = 0 ;
18379 int res1 = 0 ;
18380 PyObject *swig_obj[1] ;
18381
18382 if (!args) SWIG_fail;
18383 swig_obj[0] = args;
18384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18385 if (!SWIG_IsOK(res1)) {
18386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18387 }
18388 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18392 wxPyEndAllowThreads(__tstate);
18393 if (PyErr_Occurred()) SWIG_fail;
18394 }
18395 {
18396 resultobj = wxPyMake_wxObject(result, 0);
18397 }
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18405 PyObject *resultobj = 0;
18406 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18407 wxEvtHandler *result = 0 ;
18408 void *argp1 = 0 ;
18409 int res1 = 0 ;
18410 PyObject *swig_obj[1] ;
18411
18412 if (!args) SWIG_fail;
18413 swig_obj[0] = args;
18414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18417 }
18418 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 resultobj = wxPyMake_wxObject(result, 0);
18427 }
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj = 0;
18436 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18437 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18438 void *argp1 = 0 ;
18439 int res1 = 0 ;
18440 void *argp2 = 0 ;
18441 int res2 = 0 ;
18442 PyObject * obj0 = 0 ;
18443 PyObject * obj1 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "handler", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18452 }
18453 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18455 if (!SWIG_IsOK(res2)) {
18456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18457 }
18458 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18459 {
18460 PyThreadState* __tstate = wxPyBeginAllowThreads();
18461 (arg1)->SetNextHandler(arg2);
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 resultobj = SWIG_Py_Void();
18466 return resultobj;
18467 fail:
18468 return NULL;
18469 }
18470
18471
18472 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18473 PyObject *resultobj = 0;
18474 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18475 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18476 void *argp1 = 0 ;
18477 int res1 = 0 ;
18478 void *argp2 = 0 ;
18479 int res2 = 0 ;
18480 PyObject * obj0 = 0 ;
18481 PyObject * obj1 = 0 ;
18482 char * kwnames[] = {
18483 (char *) "self",(char *) "handler", NULL
18484 };
18485
18486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18490 }
18491 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18493 if (!SWIG_IsOK(res2)) {
18494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18495 }
18496 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 (arg1)->SetPreviousHandler(arg2);
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 resultobj = SWIG_Py_Void();
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18511 PyObject *resultobj = 0;
18512 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18513 bool result;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 PyObject *swig_obj[1] ;
18517
18518 if (!args) SWIG_fail;
18519 swig_obj[0] = args;
18520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18523 }
18524 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (bool)(arg1)->GetEvtHandlerEnabled();
18528 wxPyEndAllowThreads(__tstate);
18529 if (PyErr_Occurred()) SWIG_fail;
18530 }
18531 {
18532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18533 }
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj = 0;
18542 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18543 bool arg2 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 bool val2 ;
18547 int ecode2 = 0 ;
18548 PyObject * obj0 = 0 ;
18549 PyObject * obj1 = 0 ;
18550 char * kwnames[] = {
18551 (char *) "self",(char *) "enabled", NULL
18552 };
18553
18554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18558 }
18559 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18561 if (!SWIG_IsOK(ecode2)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18563 }
18564 arg2 = static_cast< bool >(val2);
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->SetEvtHandlerEnabled(arg2);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_Py_Void();
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18579 PyObject *resultobj = 0;
18580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18581 wxEvent *arg2 = 0 ;
18582 bool result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 void *argp2 = 0 ;
18586 int res2 = 0 ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char * kwnames[] = {
18590 (char *) "self",(char *) "event", NULL
18591 };
18592
18593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18595 if (!SWIG_IsOK(res1)) {
18596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18597 }
18598 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18599 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18600 if (!SWIG_IsOK(res2)) {
18601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18602 }
18603 if (!argp2) {
18604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18605 }
18606 arg2 = reinterpret_cast< wxEvent * >(argp2);
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = (bool)(arg1)->ProcessEvent(*arg2);
18610 wxPyEndAllowThreads(__tstate);
18611 if (PyErr_Occurred()) SWIG_fail;
18612 }
18613 {
18614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18615 }
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18625 wxEvent *arg2 = 0 ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 void *argp2 = 0 ;
18629 int res2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "event", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18642 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18643 if (!SWIG_IsOK(res2)) {
18644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18645 }
18646 if (!argp2) {
18647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18648 }
18649 arg2 = reinterpret_cast< wxEvent * >(argp2);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 (arg1)->AddPendingEvent(*arg2);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_Py_Void();
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxEvtHandler *arg1 = (wxEvtHandler *) 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_wxEvtHandler, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18675 }
18676 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 (arg1)->ProcessPendingEvents();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 resultobj = SWIG_Py_Void();
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj = 0;
18692 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18693 bool arg2 = (bool) true ;
18694 void *argp1 = 0 ;
18695 int res1 = 0 ;
18696 bool val2 ;
18697 int ecode2 = 0 ;
18698 PyObject * obj0 = 0 ;
18699 PyObject * obj1 = 0 ;
18700 char * kwnames[] = {
18701 (char *) "self",(char *) "allow", NULL
18702 };
18703
18704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18706 if (!SWIG_IsOK(res1)) {
18707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18708 }
18709 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18710 if (obj1) {
18711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18712 if (!SWIG_IsOK(ecode2)) {
18713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18714 }
18715 arg2 = static_cast< bool >(val2);
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 (arg1)->AllowReentrance(arg2);
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 resultobj = SWIG_Py_Void();
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18731 PyObject *resultobj = 0;
18732 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18733 bool result;
18734 void *argp1 = 0 ;
18735 int res1 = 0 ;
18736 PyObject *swig_obj[1] ;
18737
18738 if (!args) SWIG_fail;
18739 swig_obj[0] = args;
18740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18741 if (!SWIG_IsOK(res1)) {
18742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18743 }
18744 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18745 {
18746 PyThreadState* __tstate = wxPyBeginAllowThreads();
18747 result = (bool)(arg1)->IsReentranceAllowed();
18748 wxPyEndAllowThreads(__tstate);
18749 if (PyErr_Occurred()) SWIG_fail;
18750 }
18751 {
18752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18753 }
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18761 PyObject *resultobj = 0;
18762 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18763 bool result;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 PyObject *swig_obj[1] ;
18767
18768 if (!args) SWIG_fail;
18769 swig_obj[0] = args;
18770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18771 if (!SWIG_IsOK(res1)) {
18772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18773 }
18774 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 result = (bool)(arg1)->IsEventHandlingInProgress();
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 {
18782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18783 }
18784 return resultobj;
18785 fail:
18786 return NULL;
18787 }
18788
18789
18790 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18791 PyObject *resultobj = 0;
18792 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18793 int arg2 ;
18794 int arg3 ;
18795 int arg4 ;
18796 PyObject *arg5 = (PyObject *) 0 ;
18797 void *argp1 = 0 ;
18798 int res1 = 0 ;
18799 int val2 ;
18800 int ecode2 = 0 ;
18801 int val3 ;
18802 int ecode3 = 0 ;
18803 int val4 ;
18804 int ecode4 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 PyObject * obj2 = 0 ;
18808 PyObject * obj3 = 0 ;
18809 PyObject * obj4 = 0 ;
18810 char * kwnames[] = {
18811 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18812 };
18813
18814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18816 if (!SWIG_IsOK(res1)) {
18817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18818 }
18819 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18820 ecode2 = SWIG_AsVal_int(obj1, &val2);
18821 if (!SWIG_IsOK(ecode2)) {
18822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18823 }
18824 arg2 = static_cast< int >(val2);
18825 ecode3 = SWIG_AsVal_int(obj2, &val3);
18826 if (!SWIG_IsOK(ecode3)) {
18827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18828 }
18829 arg3 = static_cast< int >(val3);
18830 ecode4 = SWIG_AsVal_int(obj3, &val4);
18831 if (!SWIG_IsOK(ecode4)) {
18832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18833 }
18834 arg4 = static_cast< int >(val4);
18835 arg5 = obj4;
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_Py_Void();
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj = 0;
18851 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18852 int arg2 ;
18853 int arg3 = (int) -1 ;
18854 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18855 bool result;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 int val2 ;
18859 int ecode2 = 0 ;
18860 int val3 ;
18861 int ecode3 = 0 ;
18862 int val4 ;
18863 int ecode4 = 0 ;
18864 PyObject * obj0 = 0 ;
18865 PyObject * obj1 = 0 ;
18866 PyObject * obj2 = 0 ;
18867 PyObject * obj3 = 0 ;
18868 char * kwnames[] = {
18869 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18870 };
18871
18872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18876 }
18877 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18878 ecode2 = SWIG_AsVal_int(obj1, &val2);
18879 if (!SWIG_IsOK(ecode2)) {
18880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18881 }
18882 arg2 = static_cast< int >(val2);
18883 if (obj2) {
18884 ecode3 = SWIG_AsVal_int(obj2, &val3);
18885 if (!SWIG_IsOK(ecode3)) {
18886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18887 }
18888 arg3 = static_cast< int >(val3);
18889 }
18890 if (obj3) {
18891 ecode4 = SWIG_AsVal_int(obj3, &val4);
18892 if (!SWIG_IsOK(ecode4)) {
18893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18894 }
18895 arg4 = static_cast< wxEventType >(val4);
18896 }
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 {
18904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj = 0;
18914 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18915 PyObject *arg2 = (PyObject *) 0 ;
18916 bool arg3 = (bool) true ;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 bool val3 ;
18920 int ecode3 = 0 ;
18921 PyObject * obj0 = 0 ;
18922 PyObject * obj1 = 0 ;
18923 PyObject * obj2 = 0 ;
18924 char * kwnames[] = {
18925 (char *) "self",(char *) "_self",(char *) "incref", NULL
18926 };
18927
18928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18930 if (!SWIG_IsOK(res1)) {
18931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18932 }
18933 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18934 arg2 = obj1;
18935 if (obj2) {
18936 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18937 if (!SWIG_IsOK(ecode3)) {
18938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18939 }
18940 arg3 = static_cast< bool >(val3);
18941 }
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18945 wxPyEndAllowThreads(__tstate);
18946 if (PyErr_Occurred()) SWIG_fail;
18947 }
18948 resultobj = SWIG_Py_Void();
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *obj;
18957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18958 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18959 return SWIG_Py_Void();
18960 }
18961
18962 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18963 return SWIG_Python_InitShadowInstance(args);
18964 }
18965
18966 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *resultobj = 0;
18968 wxEventType result;
18969
18970 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (wxEventType)wxNewEventType();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_From_int(static_cast< int >(result));
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18985 PyObject *resultobj = 0;
18986 wxEvent *arg1 = (wxEvent *) 0 ;
18987 void *argp1 = 0 ;
18988 int res1 = 0 ;
18989 PyObject *swig_obj[1] ;
18990
18991 if (!args) SWIG_fail;
18992 swig_obj[0] = args;
18993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18994 if (!SWIG_IsOK(res1)) {
18995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18996 }
18997 arg1 = reinterpret_cast< wxEvent * >(argp1);
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 delete arg1;
19001
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_Py_Void();
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxEvent *arg1 = (wxEvent *) 0 ;
19015 wxEventType arg2 ;
19016 void *argp1 = 0 ;
19017 int res1 = 0 ;
19018 int val2 ;
19019 int ecode2 = 0 ;
19020 PyObject * obj0 = 0 ;
19021 PyObject * obj1 = 0 ;
19022 char * kwnames[] = {
19023 (char *) "self",(char *) "typ", NULL
19024 };
19025
19026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19028 if (!SWIG_IsOK(res1)) {
19029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 ecode2 = SWIG_AsVal_int(obj1, &val2);
19033 if (!SWIG_IsOK(ecode2)) {
19034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19035 }
19036 arg2 = static_cast< wxEventType >(val2);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 (arg1)->SetEventType(arg2);
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = SWIG_Py_Void();
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19051 PyObject *resultobj = 0;
19052 wxEvent *arg1 = (wxEvent *) 0 ;
19053 wxEventType result;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject *swig_obj[1] ;
19057
19058 if (!args) SWIG_fail;
19059 swig_obj[0] = args;
19060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19063 }
19064 arg1 = reinterpret_cast< wxEvent * >(argp1);
19065 {
19066 PyThreadState* __tstate = wxPyBeginAllowThreads();
19067 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 resultobj = SWIG_From_int(static_cast< int >(result));
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19079 PyObject *resultobj = 0;
19080 wxEvent *arg1 = (wxEvent *) 0 ;
19081 wxObject *result = 0 ;
19082 void *argp1 = 0 ;
19083 int res1 = 0 ;
19084 PyObject *swig_obj[1] ;
19085
19086 if (!args) SWIG_fail;
19087 swig_obj[0] = args;
19088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19089 if (!SWIG_IsOK(res1)) {
19090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19091 }
19092 arg1 = reinterpret_cast< wxEvent * >(argp1);
19093 {
19094 PyThreadState* __tstate = wxPyBeginAllowThreads();
19095 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 {
19100 resultobj = wxPyMake_wxObject(result, (bool)0);
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj = 0;
19110 wxEvent *arg1 = (wxEvent *) 0 ;
19111 wxObject *arg2 = (wxObject *) 0 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 void *argp2 = 0 ;
19115 int res2 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 char * kwnames[] = {
19119 (char *) "self",(char *) "obj", NULL
19120 };
19121
19122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19124 if (!SWIG_IsOK(res1)) {
19125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19126 }
19127 arg1 = reinterpret_cast< wxEvent * >(argp1);
19128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19129 if (!SWIG_IsOK(res2)) {
19130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19131 }
19132 arg2 = reinterpret_cast< wxObject * >(argp2);
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 (arg1)->SetEventObject(arg2);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = SWIG_Py_Void();
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19147 PyObject *resultobj = 0;
19148 wxEvent *arg1 = (wxEvent *) 0 ;
19149 long result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject *swig_obj[1] ;
19153
19154 if (!args) SWIG_fail;
19155 swig_obj[0] = args;
19156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19159 }
19160 arg1 = reinterpret_cast< wxEvent * >(argp1);
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_From_long(static_cast< long >(result));
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj = 0;
19176 wxEvent *arg1 = (wxEvent *) 0 ;
19177 long arg2 = (long) 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 long val2 ;
19181 int ecode2 = 0 ;
19182 PyObject * obj0 = 0 ;
19183 PyObject * obj1 = 0 ;
19184 char * kwnames[] = {
19185 (char *) "self",(char *) "ts", NULL
19186 };
19187
19188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19190 if (!SWIG_IsOK(res1)) {
19191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19192 }
19193 arg1 = reinterpret_cast< wxEvent * >(argp1);
19194 if (obj1) {
19195 ecode2 = SWIG_AsVal_long(obj1, &val2);
19196 if (!SWIG_IsOK(ecode2)) {
19197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19198 }
19199 arg2 = static_cast< long >(val2);
19200 }
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 (arg1)->SetTimestamp(arg2);
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_Py_Void();
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19215 PyObject *resultobj = 0;
19216 wxEvent *arg1 = (wxEvent *) 0 ;
19217 int result;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 PyObject *swig_obj[1] ;
19221
19222 if (!args) SWIG_fail;
19223 swig_obj[0] = args;
19224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19227 }
19228 arg1 = reinterpret_cast< wxEvent * >(argp1);
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (int)((wxEvent const *)arg1)->GetId();
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = SWIG_From_int(static_cast< int >(result));
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19243 PyObject *resultobj = 0;
19244 wxEvent *arg1 = (wxEvent *) 0 ;
19245 int arg2 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 int val2 ;
19249 int ecode2 = 0 ;
19250 PyObject * obj0 = 0 ;
19251 PyObject * obj1 = 0 ;
19252 char * kwnames[] = {
19253 (char *) "self",(char *) "Id", NULL
19254 };
19255
19256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19258 if (!SWIG_IsOK(res1)) {
19259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19260 }
19261 arg1 = reinterpret_cast< wxEvent * >(argp1);
19262 ecode2 = SWIG_AsVal_int(obj1, &val2);
19263 if (!SWIG_IsOK(ecode2)) {
19264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19265 }
19266 arg2 = static_cast< int >(val2);
19267 {
19268 PyThreadState* __tstate = wxPyBeginAllowThreads();
19269 (arg1)->SetId(arg2);
19270 wxPyEndAllowThreads(__tstate);
19271 if (PyErr_Occurred()) SWIG_fail;
19272 }
19273 resultobj = SWIG_Py_Void();
19274 return resultobj;
19275 fail:
19276 return NULL;
19277 }
19278
19279
19280 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19281 PyObject *resultobj = 0;
19282 wxEvent *arg1 = (wxEvent *) 0 ;
19283 bool result;
19284 void *argp1 = 0 ;
19285 int res1 = 0 ;
19286 PyObject *swig_obj[1] ;
19287
19288 if (!args) SWIG_fail;
19289 swig_obj[0] = args;
19290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19291 if (!SWIG_IsOK(res1)) {
19292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19293 }
19294 arg1 = reinterpret_cast< wxEvent * >(argp1);
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj = 0;
19312 wxEvent *arg1 = (wxEvent *) 0 ;
19313 bool arg2 = (bool) true ;
19314 void *argp1 = 0 ;
19315 int res1 = 0 ;
19316 bool val2 ;
19317 int ecode2 = 0 ;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 char * kwnames[] = {
19321 (char *) "self",(char *) "skip", NULL
19322 };
19323
19324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19326 if (!SWIG_IsOK(res1)) {
19327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19328 }
19329 arg1 = reinterpret_cast< wxEvent * >(argp1);
19330 if (obj1) {
19331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19332 if (!SWIG_IsOK(ecode2)) {
19333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19334 }
19335 arg2 = static_cast< bool >(val2);
19336 }
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 (arg1)->Skip(arg2);
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_Py_Void();
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxEvent *arg1 = (wxEvent *) 0 ;
19353 bool result;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19363 }
19364 arg1 = reinterpret_cast< wxEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 {
19372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19373 }
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19381 PyObject *resultobj = 0;
19382 wxEvent *arg1 = (wxEvent *) 0 ;
19383 bool result;
19384 void *argp1 = 0 ;
19385 int res1 = 0 ;
19386 PyObject *swig_obj[1] ;
19387
19388 if (!args) SWIG_fail;
19389 swig_obj[0] = args;
19390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19391 if (!SWIG_IsOK(res1)) {
19392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19393 }
19394 arg1 = reinterpret_cast< wxEvent * >(argp1);
19395 {
19396 PyThreadState* __tstate = wxPyBeginAllowThreads();
19397 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19398 wxPyEndAllowThreads(__tstate);
19399 if (PyErr_Occurred()) SWIG_fail;
19400 }
19401 {
19402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19403 }
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxEvent *arg1 = (wxEvent *) 0 ;
19413 int result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19423 }
19424 arg1 = reinterpret_cast< wxEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (int)(arg1)->StopPropagation();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = SWIG_From_int(static_cast< int >(result));
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj = 0;
19440 wxEvent *arg1 = (wxEvent *) 0 ;
19441 int arg2 ;
19442 void *argp1 = 0 ;
19443 int res1 = 0 ;
19444 int val2 ;
19445 int ecode2 = 0 ;
19446 PyObject * obj0 = 0 ;
19447 PyObject * obj1 = 0 ;
19448 char * kwnames[] = {
19449 (char *) "self",(char *) "propagationLevel", NULL
19450 };
19451
19452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19454 if (!SWIG_IsOK(res1)) {
19455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19456 }
19457 arg1 = reinterpret_cast< wxEvent * >(argp1);
19458 ecode2 = SWIG_AsVal_int(obj1, &val2);
19459 if (!SWIG_IsOK(ecode2)) {
19460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19461 }
19462 arg2 = static_cast< int >(val2);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 (arg1)->ResumePropagation(arg2);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_Py_Void();
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 wxEvent *arg1 = (wxEvent *) 0 ;
19479 wxEvent *result = 0 ;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 PyObject *swig_obj[1] ;
19483
19484 if (!args) SWIG_fail;
19485 swig_obj[0] = args;
19486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19489 }
19490 arg1 = reinterpret_cast< wxEvent * >(argp1);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (wxEvent *)(arg1)->Clone();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *obj;
19506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19507 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19508 return SWIG_Py_Void();
19509 }
19510
19511 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj = 0;
19513 wxEvent *arg1 = 0 ;
19514 wxPropagationDisabler *result = 0 ;
19515 void *argp1 = 0 ;
19516 int res1 = 0 ;
19517 PyObject * obj0 = 0 ;
19518 char * kwnames[] = {
19519 (char *) "event", NULL
19520 };
19521
19522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19523 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19524 if (!SWIG_IsOK(res1)) {
19525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19526 }
19527 if (!argp1) {
19528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19529 }
19530 arg1 = reinterpret_cast< wxEvent * >(argp1);
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19545 PyObject *resultobj = 0;
19546 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19547 void *argp1 = 0 ;
19548 int res1 = 0 ;
19549 PyObject *swig_obj[1] ;
19550
19551 if (!args) SWIG_fail;
19552 swig_obj[0] = args;
19553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19554 if (!SWIG_IsOK(res1)) {
19555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19556 }
19557 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 delete arg1;
19561
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_Py_Void();
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19573 PyObject *obj;
19574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19575 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19576 return SWIG_Py_Void();
19577 }
19578
19579 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19580 return SWIG_Python_InitShadowInstance(args);
19581 }
19582
19583 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19584 PyObject *resultobj = 0;
19585 wxEvent *arg1 = 0 ;
19586 wxPropagateOnce *result = 0 ;
19587 void *argp1 = 0 ;
19588 int res1 = 0 ;
19589 PyObject * obj0 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "event", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19598 }
19599 if (!argp1) {
19600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19601 }
19602 arg1 = reinterpret_cast< wxEvent * >(argp1);
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *resultobj = 0;
19618 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
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_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19628 }
19629 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 delete arg1;
19633
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_Py_Void();
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *obj;
19646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19647 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19648 return SWIG_Py_Void();
19649 }
19650
19651 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19652 return SWIG_Python_InitShadowInstance(args);
19653 }
19654
19655 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19656 PyObject *resultobj = 0;
19657 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19658 int arg2 = (int) 0 ;
19659 wxCommandEvent *result = 0 ;
19660 int val1 ;
19661 int ecode1 = 0 ;
19662 int val2 ;
19663 int ecode2 = 0 ;
19664 PyObject * obj0 = 0 ;
19665 PyObject * obj1 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "commandType",(char *) "winid", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19671 if (obj0) {
19672 ecode1 = SWIG_AsVal_int(obj0, &val1);
19673 if (!SWIG_IsOK(ecode1)) {
19674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19675 }
19676 arg1 = static_cast< wxEventType >(val1);
19677 }
19678 if (obj1) {
19679 ecode2 = SWIG_AsVal_int(obj1, &val2);
19680 if (!SWIG_IsOK(ecode2)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19682 }
19683 arg2 = static_cast< int >(val2);
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19701 int result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 resultobj = SWIG_From_int(static_cast< int >(result));
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19727 PyObject *resultobj = 0;
19728 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19729 wxString *arg2 = 0 ;
19730 void *argp1 = 0 ;
19731 int res1 = 0 ;
19732 bool temp2 = false ;
19733 PyObject * obj0 = 0 ;
19734 PyObject * obj1 = 0 ;
19735 char * kwnames[] = {
19736 (char *) "self",(char *) "s", NULL
19737 };
19738
19739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19741 if (!SWIG_IsOK(res1)) {
19742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19743 }
19744 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19745 {
19746 arg2 = wxString_in_helper(obj1);
19747 if (arg2 == NULL) SWIG_fail;
19748 temp2 = true;
19749 }
19750 {
19751 PyThreadState* __tstate = wxPyBeginAllowThreads();
19752 (arg1)->SetString((wxString const &)*arg2);
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 resultobj = SWIG_Py_Void();
19757 {
19758 if (temp2)
19759 delete arg2;
19760 }
19761 return resultobj;
19762 fail:
19763 {
19764 if (temp2)
19765 delete arg2;
19766 }
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19772 PyObject *resultobj = 0;
19773 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19774 wxString result;
19775 void *argp1 = 0 ;
19776 int res1 = 0 ;
19777 PyObject *swig_obj[1] ;
19778
19779 if (!args) SWIG_fail;
19780 swig_obj[0] = args;
19781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19782 if (!SWIG_IsOK(res1)) {
19783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19784 }
19785 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 result = ((wxCommandEvent const *)arg1)->GetString();
19789 wxPyEndAllowThreads(__tstate);
19790 if (PyErr_Occurred()) SWIG_fail;
19791 }
19792 {
19793 #if wxUSE_UNICODE
19794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19795 #else
19796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19797 #endif
19798 }
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19806 PyObject *resultobj = 0;
19807 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19808 bool result;
19809 void *argp1 = 0 ;
19810 int res1 = 0 ;
19811 PyObject *swig_obj[1] ;
19812
19813 if (!args) SWIG_fail;
19814 swig_obj[0] = args;
19815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19818 }
19819 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19820 {
19821 PyThreadState* __tstate = wxPyBeginAllowThreads();
19822 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19823 wxPyEndAllowThreads(__tstate);
19824 if (PyErr_Occurred()) SWIG_fail;
19825 }
19826 {
19827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19828 }
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19836 PyObject *resultobj = 0;
19837 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19838 bool result;
19839 void *argp1 = 0 ;
19840 int res1 = 0 ;
19841 PyObject *swig_obj[1] ;
19842
19843 if (!args) SWIG_fail;
19844 swig_obj[0] = args;
19845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19846 if (!SWIG_IsOK(res1)) {
19847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19848 }
19849 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
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_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = 0;
19867 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19868 long arg2 ;
19869 void *argp1 = 0 ;
19870 int res1 = 0 ;
19871 long val2 ;
19872 int ecode2 = 0 ;
19873 PyObject * obj0 = 0 ;
19874 PyObject * obj1 = 0 ;
19875 char * kwnames[] = {
19876 (char *) "self",(char *) "extraLong", NULL
19877 };
19878
19879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19881 if (!SWIG_IsOK(res1)) {
19882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19883 }
19884 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19885 ecode2 = SWIG_AsVal_long(obj1, &val2);
19886 if (!SWIG_IsOK(ecode2)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19888 }
19889 arg2 = static_cast< long >(val2);
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 (arg1)->SetExtraLong(arg2);
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 resultobj = SWIG_Py_Void();
19897 return resultobj;
19898 fail:
19899 return NULL;
19900 }
19901
19902
19903 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19904 PyObject *resultobj = 0;
19905 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19906 long result;
19907 void *argp1 = 0 ;
19908 int res1 = 0 ;
19909 PyObject *swig_obj[1] ;
19910
19911 if (!args) SWIG_fail;
19912 swig_obj[0] = args;
19913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19914 if (!SWIG_IsOK(res1)) {
19915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19916 }
19917 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 resultobj = SWIG_From_long(static_cast< long >(result));
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19932 PyObject *resultobj = 0;
19933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19934 int arg2 ;
19935 void *argp1 = 0 ;
19936 int res1 = 0 ;
19937 int val2 ;
19938 int ecode2 = 0 ;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 char * kwnames[] = {
19942 (char *) "self",(char *) "i", NULL
19943 };
19944
19945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19947 if (!SWIG_IsOK(res1)) {
19948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19949 }
19950 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19951 ecode2 = SWIG_AsVal_int(obj1, &val2);
19952 if (!SWIG_IsOK(ecode2)) {
19953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19954 }
19955 arg2 = static_cast< int >(val2);
19956 {
19957 PyThreadState* __tstate = wxPyBeginAllowThreads();
19958 (arg1)->SetInt(arg2);
19959 wxPyEndAllowThreads(__tstate);
19960 if (PyErr_Occurred()) SWIG_fail;
19961 }
19962 resultobj = SWIG_Py_Void();
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19970 PyObject *resultobj = 0;
19971 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19972 int result;
19973 void *argp1 = 0 ;
19974 int res1 = 0 ;
19975 PyObject *swig_obj[1] ;
19976
19977 if (!args) SWIG_fail;
19978 swig_obj[0] = args;
19979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_From_int(static_cast< int >(result));
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19998 PyObject *resultobj = 0;
19999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20000 PyObject *result = 0 ;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject *swig_obj[1] ;
20004
20005 if (!args) SWIG_fail;
20006 swig_obj[0] = args;
20007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20010 }
20011 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 resultobj = result;
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20026 PyObject *resultobj = 0;
20027 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20028 PyObject *arg2 = (PyObject *) 0 ;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "self",(char *) "clientData", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20041 }
20042 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20043 arg2 = obj1;
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 wxCommandEvent_SetClientData(arg1,arg2);
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_Py_Void();
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *resultobj = 0;
20059 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20060 wxEvent *result = 0 ;
20061 void *argp1 = 0 ;
20062 int res1 = 0 ;
20063 PyObject *swig_obj[1] ;
20064
20065 if (!args) SWIG_fail;
20066 swig_obj[0] = args;
20067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20068 if (!SWIG_IsOK(res1)) {
20069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20070 }
20071 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20079 return resultobj;
20080 fail:
20081 return NULL;
20082 }
20083
20084
20085 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20086 PyObject *obj;
20087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20088 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20089 return SWIG_Py_Void();
20090 }
20091
20092 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 return SWIG_Python_InitShadowInstance(args);
20094 }
20095
20096 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20097 PyObject *resultobj = 0;
20098 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20099 int arg2 = (int) 0 ;
20100 wxNotifyEvent *result = 0 ;
20101 int val1 ;
20102 int ecode1 = 0 ;
20103 int val2 ;
20104 int ecode2 = 0 ;
20105 PyObject * obj0 = 0 ;
20106 PyObject * obj1 = 0 ;
20107 char * kwnames[] = {
20108 (char *) "commandType",(char *) "winid", NULL
20109 };
20110
20111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20112 if (obj0) {
20113 ecode1 = SWIG_AsVal_int(obj0, &val1);
20114 if (!SWIG_IsOK(ecode1)) {
20115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20116 }
20117 arg1 = static_cast< wxEventType >(val1);
20118 }
20119 if (obj1) {
20120 ecode2 = SWIG_AsVal_int(obj1, &val2);
20121 if (!SWIG_IsOK(ecode2)) {
20122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20123 }
20124 arg2 = static_cast< int >(val2);
20125 }
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20129 wxPyEndAllowThreads(__tstate);
20130 if (PyErr_Occurred()) SWIG_fail;
20131 }
20132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20133 return resultobj;
20134 fail:
20135 return NULL;
20136 }
20137
20138
20139 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20140 PyObject *resultobj = 0;
20141 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20142 void *argp1 = 0 ;
20143 int res1 = 0 ;
20144 PyObject *swig_obj[1] ;
20145
20146 if (!args) SWIG_fail;
20147 swig_obj[0] = args;
20148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20151 }
20152 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 (arg1)->Veto();
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 resultobj = SWIG_Py_Void();
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20167 PyObject *resultobj = 0;
20168 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20169 void *argp1 = 0 ;
20170 int res1 = 0 ;
20171 PyObject *swig_obj[1] ;
20172
20173 if (!args) SWIG_fail;
20174 swig_obj[0] = args;
20175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20176 if (!SWIG_IsOK(res1)) {
20177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20178 }
20179 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 (arg1)->Allow();
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 resultobj = SWIG_Py_Void();
20187 return resultobj;
20188 fail:
20189 return NULL;
20190 }
20191
20192
20193 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20194 PyObject *resultobj = 0;
20195 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20196 bool result;
20197 void *argp1 = 0 ;
20198 int res1 = 0 ;
20199 PyObject *swig_obj[1] ;
20200
20201 if (!args) SWIG_fail;
20202 swig_obj[0] = args;
20203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20206 }
20207 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = (bool)(arg1)->IsAllowed();
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 {
20215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20216 }
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20224 PyObject *obj;
20225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20226 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20227 return SWIG_Py_Void();
20228 }
20229
20230 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20231 return SWIG_Python_InitShadowInstance(args);
20232 }
20233
20234 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20235 PyObject *resultobj = 0;
20236 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20237 int arg2 = (int) 0 ;
20238 int arg3 = (int) 0 ;
20239 int arg4 = (int) 0 ;
20240 wxScrollEvent *result = 0 ;
20241 int val1 ;
20242 int ecode1 = 0 ;
20243 int val2 ;
20244 int ecode2 = 0 ;
20245 int val3 ;
20246 int ecode3 = 0 ;
20247 int val4 ;
20248 int ecode4 = 0 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 PyObject * obj2 = 0 ;
20252 PyObject * obj3 = 0 ;
20253 char * kwnames[] = {
20254 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20255 };
20256
20257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20258 if (obj0) {
20259 ecode1 = SWIG_AsVal_int(obj0, &val1);
20260 if (!SWIG_IsOK(ecode1)) {
20261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20262 }
20263 arg1 = static_cast< wxEventType >(val1);
20264 }
20265 if (obj1) {
20266 ecode2 = SWIG_AsVal_int(obj1, &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20269 }
20270 arg2 = static_cast< int >(val2);
20271 }
20272 if (obj2) {
20273 ecode3 = SWIG_AsVal_int(obj2, &val3);
20274 if (!SWIG_IsOK(ecode3)) {
20275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20276 }
20277 arg3 = static_cast< int >(val3);
20278 }
20279 if (obj3) {
20280 ecode4 = SWIG_AsVal_int(obj3, &val4);
20281 if (!SWIG_IsOK(ecode4)) {
20282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20283 }
20284 arg4 = static_cast< int >(val4);
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20302 int result;
20303 void *argp1 = 0 ;
20304 int res1 = 0 ;
20305 PyObject *swig_obj[1] ;
20306
20307 if (!args) SWIG_fail;
20308 swig_obj[0] = args;
20309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 resultobj = SWIG_From_int(static_cast< int >(result));
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20330 int result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 PyObject *swig_obj[1] ;
20334
20335 if (!args) SWIG_fail;
20336 swig_obj[0] = args;
20337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20340 }
20341 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20342 {
20343 PyThreadState* __tstate = wxPyBeginAllowThreads();
20344 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 resultobj = SWIG_From_int(static_cast< int >(result));
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20356 PyObject *resultobj = 0;
20357 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20358 int arg2 ;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 int val2 ;
20362 int ecode2 = 0 ;
20363 PyObject * obj0 = 0 ;
20364 PyObject * obj1 = 0 ;
20365 char * kwnames[] = {
20366 (char *) "self",(char *) "orient", NULL
20367 };
20368
20369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20371 if (!SWIG_IsOK(res1)) {
20372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20373 }
20374 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20375 ecode2 = SWIG_AsVal_int(obj1, &val2);
20376 if (!SWIG_IsOK(ecode2)) {
20377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20378 }
20379 arg2 = static_cast< int >(val2);
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 (arg1)->SetOrientation(arg2);
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 resultobj = SWIG_Py_Void();
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj = 0;
20395 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20396 int arg2 ;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 int val2 ;
20400 int ecode2 = 0 ;
20401 PyObject * obj0 = 0 ;
20402 PyObject * obj1 = 0 ;
20403 char * kwnames[] = {
20404 (char *) "self",(char *) "pos", NULL
20405 };
20406
20407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20409 if (!SWIG_IsOK(res1)) {
20410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20411 }
20412 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20413 ecode2 = SWIG_AsVal_int(obj1, &val2);
20414 if (!SWIG_IsOK(ecode2)) {
20415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20416 }
20417 arg2 = static_cast< int >(val2);
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 (arg1)->SetPosition(arg2);
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 resultobj = SWIG_Py_Void();
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *obj;
20433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20434 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20435 return SWIG_Py_Void();
20436 }
20437
20438 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20439 return SWIG_Python_InitShadowInstance(args);
20440 }
20441
20442 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20443 PyObject *resultobj = 0;
20444 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20445 int arg2 = (int) 0 ;
20446 int arg3 = (int) 0 ;
20447 wxScrollWinEvent *result = 0 ;
20448 int val1 ;
20449 int ecode1 = 0 ;
20450 int val2 ;
20451 int ecode2 = 0 ;
20452 int val3 ;
20453 int ecode3 = 0 ;
20454 PyObject * obj0 = 0 ;
20455 PyObject * obj1 = 0 ;
20456 PyObject * obj2 = 0 ;
20457 char * kwnames[] = {
20458 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20459 };
20460
20461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20462 if (obj0) {
20463 ecode1 = SWIG_AsVal_int(obj0, &val1);
20464 if (!SWIG_IsOK(ecode1)) {
20465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20466 }
20467 arg1 = static_cast< wxEventType >(val1);
20468 }
20469 if (obj1) {
20470 ecode2 = SWIG_AsVal_int(obj1, &val2);
20471 if (!SWIG_IsOK(ecode2)) {
20472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20473 }
20474 arg2 = static_cast< int >(val2);
20475 }
20476 if (obj2) {
20477 ecode3 = SWIG_AsVal_int(obj2, &val3);
20478 if (!SWIG_IsOK(ecode3)) {
20479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20480 }
20481 arg3 = static_cast< int >(val3);
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20497 PyObject *resultobj = 0;
20498 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20499 int result;
20500 void *argp1 = 0 ;
20501 int res1 = 0 ;
20502 PyObject *swig_obj[1] ;
20503
20504 if (!args) SWIG_fail;
20505 swig_obj[0] = args;
20506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20507 if (!SWIG_IsOK(res1)) {
20508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20509 }
20510 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_From_int(static_cast< int >(result));
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20527 int result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20537 }
20538 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 resultobj = SWIG_From_int(static_cast< int >(result));
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20553 PyObject *resultobj = 0;
20554 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20555 int arg2 ;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 int val2 ;
20559 int ecode2 = 0 ;
20560 PyObject * obj0 = 0 ;
20561 PyObject * obj1 = 0 ;
20562 char * kwnames[] = {
20563 (char *) "self",(char *) "orient", NULL
20564 };
20565
20566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20568 if (!SWIG_IsOK(res1)) {
20569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20570 }
20571 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20572 ecode2 = SWIG_AsVal_int(obj1, &val2);
20573 if (!SWIG_IsOK(ecode2)) {
20574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20575 }
20576 arg2 = static_cast< int >(val2);
20577 {
20578 PyThreadState* __tstate = wxPyBeginAllowThreads();
20579 (arg1)->SetOrientation(arg2);
20580 wxPyEndAllowThreads(__tstate);
20581 if (PyErr_Occurred()) SWIG_fail;
20582 }
20583 resultobj = SWIG_Py_Void();
20584 return resultobj;
20585 fail:
20586 return NULL;
20587 }
20588
20589
20590 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20591 PyObject *resultobj = 0;
20592 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20593 int arg2 ;
20594 void *argp1 = 0 ;
20595 int res1 = 0 ;
20596 int val2 ;
20597 int ecode2 = 0 ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char * kwnames[] = {
20601 (char *) "self",(char *) "pos", NULL
20602 };
20603
20604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20608 }
20609 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20610 ecode2 = SWIG_AsVal_int(obj1, &val2);
20611 if (!SWIG_IsOK(ecode2)) {
20612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20613 }
20614 arg2 = static_cast< int >(val2);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 (arg1)->SetPosition(arg2);
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 resultobj = SWIG_Py_Void();
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20629 PyObject *obj;
20630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20631 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20632 return SWIG_Py_Void();
20633 }
20634
20635 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20636 return SWIG_Python_InitShadowInstance(args);
20637 }
20638
20639 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj = 0;
20641 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20642 wxMouseEvent *result = 0 ;
20643 int val1 ;
20644 int ecode1 = 0 ;
20645 PyObject * obj0 = 0 ;
20646 char * kwnames[] = {
20647 (char *) "mouseType", NULL
20648 };
20649
20650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20651 if (obj0) {
20652 ecode1 = SWIG_AsVal_int(obj0, &val1);
20653 if (!SWIG_IsOK(ecode1)) {
20654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20655 }
20656 arg1 = static_cast< wxEventType >(val1);
20657 }
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 {
20665 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20666 }
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20674 PyObject *resultobj = 0;
20675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20676 bool result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 PyObject *swig_obj[1] ;
20680
20681 if (!args) SWIG_fail;
20682 swig_obj[0] = args;
20683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20686 }
20687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20696 }
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj = 0;
20705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20706 int arg2 = (int) wxMOUSE_BTN_ANY ;
20707 bool result;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 int val2 ;
20711 int ecode2 = 0 ;
20712 PyObject * obj0 = 0 ;
20713 PyObject * obj1 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "self",(char *) "but", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20722 }
20723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20724 if (obj1) {
20725 ecode2 = SWIG_AsVal_int(obj1, &val2);
20726 if (!SWIG_IsOK(ecode2)) {
20727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20728 }
20729 arg2 = static_cast< int >(val2);
20730 }
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj = 0;
20748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20749 int arg2 = (int) wxMOUSE_BTN_ANY ;
20750 bool result;
20751 void *argp1 = 0 ;
20752 int res1 = 0 ;
20753 int val2 ;
20754 int ecode2 = 0 ;
20755 PyObject * obj0 = 0 ;
20756 PyObject * obj1 = 0 ;
20757 char * kwnames[] = {
20758 (char *) "self",(char *) "but", NULL
20759 };
20760
20761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20763 if (!SWIG_IsOK(res1)) {
20764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20765 }
20766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20767 if (obj1) {
20768 ecode2 = SWIG_AsVal_int(obj1, &val2);
20769 if (!SWIG_IsOK(ecode2)) {
20770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20771 }
20772 arg2 = static_cast< int >(val2);
20773 }
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 {
20781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20782 }
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20790 PyObject *resultobj = 0;
20791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20792 int arg2 = (int) wxMOUSE_BTN_ANY ;
20793 bool result;
20794 void *argp1 = 0 ;
20795 int res1 = 0 ;
20796 int val2 ;
20797 int ecode2 = 0 ;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 char * kwnames[] = {
20801 (char *) "self",(char *) "but", NULL
20802 };
20803
20804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20806 if (!SWIG_IsOK(res1)) {
20807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20808 }
20809 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20810 if (obj1) {
20811 ecode2 = SWIG_AsVal_int(obj1, &val2);
20812 if (!SWIG_IsOK(ecode2)) {
20813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20814 }
20815 arg2 = static_cast< int >(val2);
20816 }
20817 {
20818 PyThreadState* __tstate = wxPyBeginAllowThreads();
20819 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20820 wxPyEndAllowThreads(__tstate);
20821 if (PyErr_Occurred()) SWIG_fail;
20822 }
20823 {
20824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20825 }
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 int arg2 ;
20836 bool result;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 int val2 ;
20840 int ecode2 = 0 ;
20841 PyObject * obj0 = 0 ;
20842 PyObject * obj1 = 0 ;
20843 char * kwnames[] = {
20844 (char *) "self",(char *) "button", NULL
20845 };
20846
20847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 ecode2 = SWIG_AsVal_int(obj1, &val2);
20854 if (!SWIG_IsOK(ecode2)) {
20855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20856 }
20857 arg2 = static_cast< int >(val2);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20866 }
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20874 PyObject *resultobj = 0;
20875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20876 int arg2 ;
20877 bool result;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 int val2 ;
20881 int ecode2 = 0 ;
20882 PyObject * obj0 = 0 ;
20883 PyObject * obj1 = 0 ;
20884 char * kwnames[] = {
20885 (char *) "self",(char *) "but", NULL
20886 };
20887
20888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20890 if (!SWIG_IsOK(res1)) {
20891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20892 }
20893 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20894 ecode2 = SWIG_AsVal_int(obj1, &val2);
20895 if (!SWIG_IsOK(ecode2)) {
20896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20897 }
20898 arg2 = static_cast< int >(val2);
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 {
20906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_From_int(static_cast< int >(result));
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 bool result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20965 }
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20973 PyObject *resultobj = 0;
20974 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20975 bool result;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 PyObject *swig_obj[1] ;
20979
20980 if (!args) SWIG_fail;
20981 swig_obj[0] = args;
20982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20985 }
20986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21003 PyObject *resultobj = 0;
21004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21005 bool result;
21006 void *argp1 = 0 ;
21007 int res1 = 0 ;
21008 PyObject *swig_obj[1] ;
21009
21010 if (!args) SWIG_fail;
21011 swig_obj[0] = args;
21012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21015 }
21016 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 {
21024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21025 }
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21035 bool result;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 PyObject *swig_obj[1] ;
21039
21040 if (!args) SWIG_fail;
21041 swig_obj[0] = args;
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_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21045 }
21046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 {
21054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21055 }
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 bool result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 {
21084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21085 }
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21093 PyObject *resultobj = 0;
21094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21095 bool result;
21096 void *argp1 = 0 ;
21097 int res1 = 0 ;
21098 PyObject *swig_obj[1] ;
21099
21100 if (!args) SWIG_fail;
21101 swig_obj[0] = args;
21102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21105 }
21106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21107 {
21108 PyThreadState* __tstate = wxPyBeginAllowThreads();
21109 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21110 wxPyEndAllowThreads(__tstate);
21111 if (PyErr_Occurred()) SWIG_fail;
21112 }
21113 {
21114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 bool result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21135 }
21136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21137 {
21138 PyThreadState* __tstate = wxPyBeginAllowThreads();
21139 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21165 }
21166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21185 bool result;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 PyObject *swig_obj[1] ;
21189
21190 if (!args) SWIG_fail;
21191 swig_obj[0] = args;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21195 }
21196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 {
21204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 PyObject *swig_obj[1] ;
21219
21220 if (!args) SWIG_fail;
21221 swig_obj[0] = args;
21222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21223 if (!SWIG_IsOK(res1)) {
21224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21225 }
21226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 {
21234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21235 }
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 bool result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21265 }
21266 return resultobj;
21267 fail:
21268 return NULL;
21269 }
21270
21271
21272 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21273 PyObject *resultobj = 0;
21274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21275 bool result;
21276 void *argp1 = 0 ;
21277 int res1 = 0 ;
21278 PyObject *swig_obj[1] ;
21279
21280 if (!args) SWIG_fail;
21281 swig_obj[0] = args;
21282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21283 if (!SWIG_IsOK(res1)) {
21284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21285 }
21286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21290 wxPyEndAllowThreads(__tstate);
21291 if (PyErr_Occurred()) SWIG_fail;
21292 }
21293 {
21294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21295 }
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 bool result;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 PyObject *swig_obj[1] ;
21309
21310 if (!args) SWIG_fail;
21311 swig_obj[0] = args;
21312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21313 if (!SWIG_IsOK(res1)) {
21314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21315 }
21316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21320 wxPyEndAllowThreads(__tstate);
21321 if (PyErr_Occurred()) SWIG_fail;
21322 }
21323 {
21324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21325 }
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21333 PyObject *resultobj = 0;
21334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21335 bool result;
21336 void *argp1 = 0 ;
21337 int res1 = 0 ;
21338 PyObject *swig_obj[1] ;
21339
21340 if (!args) SWIG_fail;
21341 swig_obj[0] = args;
21342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21345 }
21346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21365 bool result;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 PyObject *swig_obj[1] ;
21369
21370 if (!args) SWIG_fail;
21371 swig_obj[0] = args;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21375 }
21376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21377 {
21378 PyThreadState* __tstate = wxPyBeginAllowThreads();
21379 result = (bool)(arg1)->LeftIsDown();
21380 wxPyEndAllowThreads(__tstate);
21381 if (PyErr_Occurred()) SWIG_fail;
21382 }
21383 {
21384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21385 }
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool result;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 PyObject *swig_obj[1] ;
21399
21400 if (!args) SWIG_fail;
21401 swig_obj[0] = args;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 {
21408 PyThreadState* __tstate = wxPyBeginAllowThreads();
21409 result = (bool)(arg1)->MiddleIsDown();
21410 wxPyEndAllowThreads(__tstate);
21411 if (PyErr_Occurred()) SWIG_fail;
21412 }
21413 {
21414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21415 }
21416 return resultobj;
21417 fail:
21418 return NULL;
21419 }
21420
21421
21422 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21423 PyObject *resultobj = 0;
21424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21425 bool result;
21426 void *argp1 = 0 ;
21427 int res1 = 0 ;
21428 PyObject *swig_obj[1] ;
21429
21430 if (!args) SWIG_fail;
21431 swig_obj[0] = args;
21432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21433 if (!SWIG_IsOK(res1)) {
21434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21435 }
21436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21437 {
21438 PyThreadState* __tstate = wxPyBeginAllowThreads();
21439 result = (bool)(arg1)->RightIsDown();
21440 wxPyEndAllowThreads(__tstate);
21441 if (PyErr_Occurred()) SWIG_fail;
21442 }
21443 {
21444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21445 }
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21455 bool result;
21456 void *argp1 = 0 ;
21457 int res1 = 0 ;
21458 PyObject *swig_obj[1] ;
21459
21460 if (!args) SWIG_fail;
21461 swig_obj[0] = args;
21462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21463 if (!SWIG_IsOK(res1)) {
21464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21465 }
21466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21470 wxPyEndAllowThreads(__tstate);
21471 if (PyErr_Occurred()) SWIG_fail;
21472 }
21473 {
21474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21475 }
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21483 PyObject *resultobj = 0;
21484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21485 bool result;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 PyObject *swig_obj[1] ;
21489
21490 if (!args) SWIG_fail;
21491 swig_obj[0] = args;
21492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513 PyObject *resultobj = 0;
21514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21515 bool result;
21516 void *argp1 = 0 ;
21517 int res1 = 0 ;
21518 PyObject *swig_obj[1] ;
21519
21520 if (!args) SWIG_fail;
21521 swig_obj[0] = args;
21522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21523 if (!SWIG_IsOK(res1)) {
21524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21525 }
21526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 {
21534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21535 }
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21543 PyObject *resultobj = 0;
21544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21545 bool result;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 PyObject *swig_obj[1] ;
21549
21550 if (!args) SWIG_fail;
21551 swig_obj[0] = args;
21552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21553 if (!SWIG_IsOK(res1)) {
21554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21555 }
21556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21557 {
21558 PyThreadState* __tstate = wxPyBeginAllowThreads();
21559 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 {
21564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21565 }
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21575 wxPoint result;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 PyObject *swig_obj[1] ;
21579
21580 if (!args) SWIG_fail;
21581 swig_obj[0] = args;
21582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21585 }
21586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (arg1)->GetPosition();
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21601 PyObject *resultobj = 0;
21602 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21603 long *arg2 = (long *) 0 ;
21604 long *arg3 = (long *) 0 ;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 long temp2 ;
21608 int res2 = SWIG_TMPOBJ ;
21609 long temp3 ;
21610 int res3 = SWIG_TMPOBJ ;
21611 PyObject *swig_obj[1] ;
21612
21613 arg2 = &temp2;
21614 arg3 = &temp3;
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 (arg1)->GetPosition(arg2,arg3);
21625 wxPyEndAllowThreads(__tstate);
21626 if (PyErr_Occurred()) SWIG_fail;
21627 }
21628 resultobj = SWIG_Py_Void();
21629 if (SWIG_IsTmpObj(res2)) {
21630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21631 } else {
21632 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21634 }
21635 if (SWIG_IsTmpObj(res3)) {
21636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21637 } else {
21638 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21640 }
21641 return resultobj;
21642 fail:
21643 return NULL;
21644 }
21645
21646
21647 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21648 PyObject *resultobj = 0;
21649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21650 wxDC *arg2 = 0 ;
21651 wxPoint result;
21652 void *argp1 = 0 ;
21653 int res1 = 0 ;
21654 void *argp2 = 0 ;
21655 int res2 = 0 ;
21656 PyObject * obj0 = 0 ;
21657 PyObject * obj1 = 0 ;
21658 char * kwnames[] = {
21659 (char *) "self",(char *) "dc", NULL
21660 };
21661
21662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21664 if (!SWIG_IsOK(res1)) {
21665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21666 }
21667 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21668 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21669 if (!SWIG_IsOK(res2)) {
21670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21671 }
21672 if (!argp2) {
21673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21674 }
21675 arg2 = reinterpret_cast< wxDC * >(argp2);
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21679 wxPyEndAllowThreads(__tstate);
21680 if (PyErr_Occurred()) SWIG_fail;
21681 }
21682 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21692 int result;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 PyObject *swig_obj[1] ;
21696
21697 if (!args) SWIG_fail;
21698 swig_obj[0] = args;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (int)((wxMouseEvent const *)arg1)->GetX();
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_From_int(static_cast< int >(result));
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21718 PyObject *resultobj = 0;
21719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21720 int result;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 PyObject *swig_obj[1] ;
21724
21725 if (!args) SWIG_fail;
21726 swig_obj[0] = args;
21727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21730 }
21731 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (int)((wxMouseEvent const *)arg1)->GetY();
21735 wxPyEndAllowThreads(__tstate);
21736 if (PyErr_Occurred()) SWIG_fail;
21737 }
21738 resultobj = SWIG_From_int(static_cast< int >(result));
21739 return resultobj;
21740 fail:
21741 return NULL;
21742 }
21743
21744
21745 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21746 PyObject *resultobj = 0;
21747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21748 int result;
21749 void *argp1 = 0 ;
21750 int res1 = 0 ;
21751 PyObject *swig_obj[1] ;
21752
21753 if (!args) SWIG_fail;
21754 swig_obj[0] = args;
21755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21758 }
21759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 resultobj = SWIG_From_int(static_cast< int >(result));
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21774 PyObject *resultobj = 0;
21775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21776 int result;
21777 void *argp1 = 0 ;
21778 int res1 = 0 ;
21779 PyObject *swig_obj[1] ;
21780
21781 if (!args) SWIG_fail;
21782 swig_obj[0] = args;
21783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21784 if (!SWIG_IsOK(res1)) {
21785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21786 }
21787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21791 wxPyEndAllowThreads(__tstate);
21792 if (PyErr_Occurred()) SWIG_fail;
21793 }
21794 resultobj = SWIG_From_int(static_cast< int >(result));
21795 return resultobj;
21796 fail:
21797 return NULL;
21798 }
21799
21800
21801 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21802 PyObject *resultobj = 0;
21803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21804 int result;
21805 void *argp1 = 0 ;
21806 int res1 = 0 ;
21807 PyObject *swig_obj[1] ;
21808
21809 if (!args) SWIG_fail;
21810 swig_obj[0] = args;
21811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21812 if (!SWIG_IsOK(res1)) {
21813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21814 }
21815 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_From_int(static_cast< int >(result));
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21830 PyObject *resultobj = 0;
21831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21832 bool result;
21833 void *argp1 = 0 ;
21834 int res1 = 0 ;
21835 PyObject *swig_obj[1] ;
21836
21837 if (!args) SWIG_fail;
21838 swig_obj[0] = args;
21839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21842 }
21843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21847 wxPyEndAllowThreads(__tstate);
21848 if (PyErr_Occurred()) SWIG_fail;
21849 }
21850 {
21851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21852 }
21853 return resultobj;
21854 fail:
21855 return NULL;
21856 }
21857
21858
21859 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21860 PyObject *resultobj = 0;
21861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21862 int arg2 ;
21863 void *argp1 = 0 ;
21864 int res1 = 0 ;
21865 int val2 ;
21866 int ecode2 = 0 ;
21867 PyObject *swig_obj[2] ;
21868
21869 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21871 if (!SWIG_IsOK(res1)) {
21872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21873 }
21874 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21875 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21876 if (!SWIG_IsOK(ecode2)) {
21877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21878 }
21879 arg2 = static_cast< int >(val2);
21880 if (arg1) (arg1)->m_x = arg2;
21881
21882 resultobj = SWIG_Py_Void();
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21890 PyObject *resultobj = 0;
21891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21892 int result;
21893 void *argp1 = 0 ;
21894 int res1 = 0 ;
21895 PyObject *swig_obj[1] ;
21896
21897 if (!args) SWIG_fail;
21898 swig_obj[0] = args;
21899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21900 if (!SWIG_IsOK(res1)) {
21901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21902 }
21903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21904 result = (int) ((arg1)->m_x);
21905 resultobj = SWIG_From_int(static_cast< int >(result));
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21915 int arg2 ;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 int val2 ;
21919 int ecode2 = 0 ;
21920 PyObject *swig_obj[2] ;
21921
21922 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21924 if (!SWIG_IsOK(res1)) {
21925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21926 }
21927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21929 if (!SWIG_IsOK(ecode2)) {
21930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21931 }
21932 arg2 = static_cast< int >(val2);
21933 if (arg1) (arg1)->m_y = arg2;
21934
21935 resultobj = SWIG_Py_Void();
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21945 int result;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 PyObject *swig_obj[1] ;
21949
21950 if (!args) SWIG_fail;
21951 swig_obj[0] = args;
21952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21955 }
21956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21957 result = (int) ((arg1)->m_y);
21958 resultobj = SWIG_From_int(static_cast< int >(result));
21959 return resultobj;
21960 fail:
21961 return NULL;
21962 }
21963
21964
21965 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21966 PyObject *resultobj = 0;
21967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21968 bool arg2 ;
21969 void *argp1 = 0 ;
21970 int res1 = 0 ;
21971 bool val2 ;
21972 int ecode2 = 0 ;
21973 PyObject *swig_obj[2] ;
21974
21975 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21979 }
21980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21981 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21982 if (!SWIG_IsOK(ecode2)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21984 }
21985 arg2 = static_cast< bool >(val2);
21986 if (arg1) (arg1)->m_leftDown = arg2;
21987
21988 resultobj = SWIG_Py_Void();
21989 return resultobj;
21990 fail:
21991 return NULL;
21992 }
21993
21994
21995 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21996 PyObject *resultobj = 0;
21997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21998 bool result;
21999 void *argp1 = 0 ;
22000 int res1 = 0 ;
22001 PyObject *swig_obj[1] ;
22002
22003 if (!args) SWIG_fail;
22004 swig_obj[0] = args;
22005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22006 if (!SWIG_IsOK(res1)) {
22007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22008 }
22009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22010 result = (bool) ((arg1)->m_leftDown);
22011 {
22012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22013 }
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22023 bool arg2 ;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 bool val2 ;
22027 int ecode2 = 0 ;
22028 PyObject *swig_obj[2] ;
22029
22030 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22032 if (!SWIG_IsOK(res1)) {
22033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22034 }
22035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22036 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22037 if (!SWIG_IsOK(ecode2)) {
22038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22039 }
22040 arg2 = static_cast< bool >(val2);
22041 if (arg1) (arg1)->m_middleDown = arg2;
22042
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22053 bool result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22063 }
22064 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22065 result = (bool) ((arg1)->m_middleDown);
22066 {
22067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22068 }
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22076 PyObject *resultobj = 0;
22077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22078 bool arg2 ;
22079 void *argp1 = 0 ;
22080 int res1 = 0 ;
22081 bool val2 ;
22082 int ecode2 = 0 ;
22083 PyObject *swig_obj[2] ;
22084
22085 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22087 if (!SWIG_IsOK(res1)) {
22088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22089 }
22090 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22091 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22092 if (!SWIG_IsOK(ecode2)) {
22093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22094 }
22095 arg2 = static_cast< bool >(val2);
22096 if (arg1) (arg1)->m_rightDown = arg2;
22097
22098 resultobj = SWIG_Py_Void();
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22108 bool result;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22118 }
22119 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22120 result = (bool) ((arg1)->m_rightDown);
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22131 PyObject *resultobj = 0;
22132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22133 bool arg2 ;
22134 void *argp1 = 0 ;
22135 int res1 = 0 ;
22136 bool val2 ;
22137 int ecode2 = 0 ;
22138 PyObject *swig_obj[2] ;
22139
22140 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22142 if (!SWIG_IsOK(res1)) {
22143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22144 }
22145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22146 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22147 if (!SWIG_IsOK(ecode2)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22149 }
22150 arg2 = static_cast< bool >(val2);
22151 if (arg1) (arg1)->m_controlDown = arg2;
22152
22153 resultobj = SWIG_Py_Void();
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 PyObject *resultobj = 0;
22162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22163 bool result;
22164 void *argp1 = 0 ;
22165 int res1 = 0 ;
22166 PyObject *swig_obj[1] ;
22167
22168 if (!args) SWIG_fail;
22169 swig_obj[0] = args;
22170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22173 }
22174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22175 result = (bool) ((arg1)->m_controlDown);
22176 {
22177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22178 }
22179 return resultobj;
22180 fail:
22181 return NULL;
22182 }
22183
22184
22185 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22186 PyObject *resultobj = 0;
22187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22188 bool arg2 ;
22189 void *argp1 = 0 ;
22190 int res1 = 0 ;
22191 bool val2 ;
22192 int ecode2 = 0 ;
22193 PyObject *swig_obj[2] ;
22194
22195 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22197 if (!SWIG_IsOK(res1)) {
22198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22199 }
22200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22201 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22202 if (!SWIG_IsOK(ecode2)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22204 }
22205 arg2 = static_cast< bool >(val2);
22206 if (arg1) (arg1)->m_shiftDown = arg2;
22207
22208 resultobj = SWIG_Py_Void();
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22218 bool result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22228 }
22229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22230 result = (bool) ((arg1)->m_shiftDown);
22231 {
22232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22233 }
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 PyObject *resultobj = 0;
22242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22243 bool arg2 ;
22244 void *argp1 = 0 ;
22245 int res1 = 0 ;
22246 bool val2 ;
22247 int ecode2 = 0 ;
22248 PyObject *swig_obj[2] ;
22249
22250 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22254 }
22255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22256 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22257 if (!SWIG_IsOK(ecode2)) {
22258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22259 }
22260 arg2 = static_cast< bool >(val2);
22261 if (arg1) (arg1)->m_altDown = arg2;
22262
22263 resultobj = SWIG_Py_Void();
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22271 PyObject *resultobj = 0;
22272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22273 bool result;
22274 void *argp1 = 0 ;
22275 int res1 = 0 ;
22276 PyObject *swig_obj[1] ;
22277
22278 if (!args) SWIG_fail;
22279 swig_obj[0] = args;
22280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22281 if (!SWIG_IsOK(res1)) {
22282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22283 }
22284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22285 result = (bool) ((arg1)->m_altDown);
22286 {
22287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22288 }
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22296 PyObject *resultobj = 0;
22297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22298 bool arg2 ;
22299 void *argp1 = 0 ;
22300 int res1 = 0 ;
22301 bool val2 ;
22302 int ecode2 = 0 ;
22303 PyObject *swig_obj[2] ;
22304
22305 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22307 if (!SWIG_IsOK(res1)) {
22308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22309 }
22310 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22311 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22312 if (!SWIG_IsOK(ecode2)) {
22313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22314 }
22315 arg2 = static_cast< bool >(val2);
22316 if (arg1) (arg1)->m_metaDown = arg2;
22317
22318 resultobj = SWIG_Py_Void();
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22326 PyObject *resultobj = 0;
22327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22328 bool result;
22329 void *argp1 = 0 ;
22330 int res1 = 0 ;
22331 PyObject *swig_obj[1] ;
22332
22333 if (!args) SWIG_fail;
22334 swig_obj[0] = args;
22335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22336 if (!SWIG_IsOK(res1)) {
22337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22338 }
22339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22340 result = (bool) ((arg1)->m_metaDown);
22341 {
22342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22343 }
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 PyObject *resultobj = 0;
22352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22353 int arg2 ;
22354 void *argp1 = 0 ;
22355 int res1 = 0 ;
22356 int val2 ;
22357 int ecode2 = 0 ;
22358 PyObject *swig_obj[2] ;
22359
22360 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22364 }
22365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22366 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22367 if (!SWIG_IsOK(ecode2)) {
22368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22369 }
22370 arg2 = static_cast< int >(val2);
22371 if (arg1) (arg1)->m_wheelRotation = arg2;
22372
22373 resultobj = SWIG_Py_Void();
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22393 }
22394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22395 result = (int) ((arg1)->m_wheelRotation);
22396 resultobj = SWIG_From_int(static_cast< int >(result));
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22406 int arg2 ;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 int val2 ;
22410 int ecode2 = 0 ;
22411 PyObject *swig_obj[2] ;
22412
22413 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22417 }
22418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22419 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22420 if (!SWIG_IsOK(ecode2)) {
22421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22422 }
22423 arg2 = static_cast< int >(val2);
22424 if (arg1) (arg1)->m_wheelDelta = arg2;
22425
22426 resultobj = SWIG_Py_Void();
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22446 }
22447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22448 result = (int) ((arg1)->m_wheelDelta);
22449 resultobj = SWIG_From_int(static_cast< int >(result));
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22459 int arg2 ;
22460 void *argp1 = 0 ;
22461 int res1 = 0 ;
22462 int val2 ;
22463 int ecode2 = 0 ;
22464 PyObject *swig_obj[2] ;
22465
22466 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22472 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22473 if (!SWIG_IsOK(ecode2)) {
22474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22475 }
22476 arg2 = static_cast< int >(val2);
22477 if (arg1) (arg1)->m_linesPerAction = arg2;
22478
22479 resultobj = SWIG_Py_Void();
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22487 PyObject *resultobj = 0;
22488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22489 int result;
22490 void *argp1 = 0 ;
22491 int res1 = 0 ;
22492 PyObject *swig_obj[1] ;
22493
22494 if (!args) SWIG_fail;
22495 swig_obj[0] = args;
22496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22497 if (!SWIG_IsOK(res1)) {
22498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22499 }
22500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22501 result = (int) ((arg1)->m_linesPerAction);
22502 resultobj = SWIG_From_int(static_cast< int >(result));
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *obj;
22511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22512 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22513 return SWIG_Py_Void();
22514 }
22515
22516 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22517 return SWIG_Python_InitShadowInstance(args);
22518 }
22519
22520 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22521 PyObject *resultobj = 0;
22522 int arg1 = (int) 0 ;
22523 int arg2 = (int) 0 ;
22524 wxSetCursorEvent *result = 0 ;
22525 int val1 ;
22526 int ecode1 = 0 ;
22527 int val2 ;
22528 int ecode2 = 0 ;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char * kwnames[] = {
22532 (char *) "x",(char *) "y", NULL
22533 };
22534
22535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22536 if (obj0) {
22537 ecode1 = SWIG_AsVal_int(obj0, &val1);
22538 if (!SWIG_IsOK(ecode1)) {
22539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22540 }
22541 arg1 = static_cast< int >(val1);
22542 }
22543 if (obj1) {
22544 ecode2 = SWIG_AsVal_int(obj1, &val2);
22545 if (!SWIG_IsOK(ecode2)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22547 }
22548 arg2 = static_cast< int >(val2);
22549 }
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22553 wxPyEndAllowThreads(__tstate);
22554 if (PyErr_Occurred()) SWIG_fail;
22555 }
22556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22557 return resultobj;
22558 fail:
22559 return NULL;
22560 }
22561
22562
22563 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22564 PyObject *resultobj = 0;
22565 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22566 int result;
22567 void *argp1 = 0 ;
22568 int res1 = 0 ;
22569 PyObject *swig_obj[1] ;
22570
22571 if (!args) SWIG_fail;
22572 swig_obj[0] = args;
22573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22574 if (!SWIG_IsOK(res1)) {
22575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22576 }
22577 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22578 {
22579 PyThreadState* __tstate = wxPyBeginAllowThreads();
22580 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 resultobj = SWIG_From_int(static_cast< int >(result));
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 PyObject *resultobj = 0;
22593 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22594 int result;
22595 void *argp1 = 0 ;
22596 int res1 = 0 ;
22597 PyObject *swig_obj[1] ;
22598
22599 if (!args) SWIG_fail;
22600 swig_obj[0] = args;
22601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22602 if (!SWIG_IsOK(res1)) {
22603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22604 }
22605 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_From_int(static_cast< int >(result));
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj = 0;
22621 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22622 wxCursor *arg2 = 0 ;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 void *argp2 = 0 ;
22626 int res2 = 0 ;
22627 PyObject * obj0 = 0 ;
22628 PyObject * obj1 = 0 ;
22629 char * kwnames[] = {
22630 (char *) "self",(char *) "cursor", NULL
22631 };
22632
22633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22639 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22640 if (!SWIG_IsOK(res2)) {
22641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22642 }
22643 if (!argp2) {
22644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22645 }
22646 arg2 = reinterpret_cast< wxCursor * >(argp2);
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 (arg1)->SetCursor((wxCursor const &)*arg2);
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_Py_Void();
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22661 PyObject *resultobj = 0;
22662 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22663 wxCursor *result = 0 ;
22664 void *argp1 = 0 ;
22665 int res1 = 0 ;
22666 PyObject *swig_obj[1] ;
22667
22668 if (!args) SWIG_fail;
22669 swig_obj[0] = args;
22670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22671 if (!SWIG_IsOK(res1)) {
22672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22673 }
22674 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 {
22678 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22679 result = (wxCursor *) &_result_ref;
22680 }
22681 wxPyEndAllowThreads(__tstate);
22682 if (PyErr_Occurred()) SWIG_fail;
22683 }
22684 {
22685 wxCursor* resultptr = new wxCursor(*result);
22686 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22687 }
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22697 bool result;
22698 void *argp1 = 0 ;
22699 int res1 = 0 ;
22700 PyObject *swig_obj[1] ;
22701
22702 if (!args) SWIG_fail;
22703 swig_obj[0] = args;
22704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22705 if (!SWIG_IsOK(res1)) {
22706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22707 }
22708 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 {
22716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22717 }
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *obj;
22726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22727 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22728 return SWIG_Py_Void();
22729 }
22730
22731 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 return SWIG_Python_InitShadowInstance(args);
22733 }
22734
22735 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj = 0;
22737 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22738 wxKeyEvent *result = 0 ;
22739 int val1 ;
22740 int ecode1 = 0 ;
22741 PyObject * obj0 = 0 ;
22742 char * kwnames[] = {
22743 (char *) "eventType", NULL
22744 };
22745
22746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22747 if (obj0) {
22748 ecode1 = SWIG_AsVal_int(obj0, &val1);
22749 if (!SWIG_IsOK(ecode1)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22751 }
22752 arg1 = static_cast< wxEventType >(val1);
22753 }
22754 {
22755 PyThreadState* __tstate = wxPyBeginAllowThreads();
22756 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22770 int result;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22780 }
22781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_From_int(static_cast< int >(result));
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22796 PyObject *resultobj = 0;
22797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22798 bool result;
22799 void *argp1 = 0 ;
22800 int res1 = 0 ;
22801 PyObject *swig_obj[1] ;
22802
22803 if (!args) SWIG_fail;
22804 swig_obj[0] = args;
22805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22806 if (!SWIG_IsOK(res1)) {
22807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22808 }
22809 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 PyObject *resultobj = 0;
22827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22828 bool result;
22829 void *argp1 = 0 ;
22830 int res1 = 0 ;
22831 PyObject *swig_obj[1] ;
22832
22833 if (!args) SWIG_fail;
22834 swig_obj[0] = args;
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_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22838 }
22839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22843 wxPyEndAllowThreads(__tstate);
22844 if (PyErr_Occurred()) SWIG_fail;
22845 }
22846 {
22847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22848 }
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22858 bool result;
22859 void *argp1 = 0 ;
22860 int res1 = 0 ;
22861 PyObject *swig_obj[1] ;
22862
22863 if (!args) SWIG_fail;
22864 swig_obj[0] = args;
22865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22868 }
22869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22870 {
22871 PyThreadState* __tstate = wxPyBeginAllowThreads();
22872 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22873 wxPyEndAllowThreads(__tstate);
22874 if (PyErr_Occurred()) SWIG_fail;
22875 }
22876 {
22877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22878 }
22879 return resultobj;
22880 fail:
22881 return NULL;
22882 }
22883
22884
22885 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 PyObject *resultobj = 0;
22887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22888 bool result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 PyObject *swig_obj[1] ;
22892
22893 if (!args) SWIG_fail;
22894 swig_obj[0] = args;
22895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22898 }
22899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 {
22907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22908 }
22909 return resultobj;
22910 fail:
22911 return NULL;
22912 }
22913
22914
22915 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916 PyObject *resultobj = 0;
22917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22918 bool result;
22919 void *argp1 = 0 ;
22920 int res1 = 0 ;
22921 PyObject *swig_obj[1] ;
22922
22923 if (!args) SWIG_fail;
22924 swig_obj[0] = args;
22925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22926 if (!SWIG_IsOK(res1)) {
22927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22928 }
22929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22933 wxPyEndAllowThreads(__tstate);
22934 if (PyErr_Occurred()) SWIG_fail;
22935 }
22936 {
22937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22938 }
22939 return resultobj;
22940 fail:
22941 return NULL;
22942 }
22943
22944
22945 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22946 PyObject *resultobj = 0;
22947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22948 bool result;
22949 void *argp1 = 0 ;
22950 int res1 = 0 ;
22951 PyObject *swig_obj[1] ;
22952
22953 if (!args) SWIG_fail;
22954 swig_obj[0] = args;
22955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22958 }
22959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 {
22967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22968 }
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 PyObject *resultobj = 0;
22977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22978 int result;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 PyObject *swig_obj[1] ;
22982
22983 if (!args) SWIG_fail;
22984 swig_obj[0] = args;
22985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22986 if (!SWIG_IsOK(res1)) {
22987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22988 }
22989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22993 wxPyEndAllowThreads(__tstate);
22994 if (PyErr_Occurred()) SWIG_fail;
22995 }
22996 resultobj = SWIG_From_int(static_cast< int >(result));
22997 return resultobj;
22998 fail:
22999 return NULL;
23000 }
23001
23002
23003 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23004 PyObject *resultobj = 0;
23005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23006 int result;
23007 void *argp1 = 0 ;
23008 int res1 = 0 ;
23009 PyObject *swig_obj[1] ;
23010
23011 if (!args) SWIG_fail;
23012 swig_obj[0] = args;
23013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23016 }
23017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 resultobj = SWIG_From_int(static_cast< int >(result));
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23032 PyObject *resultobj = 0;
23033 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23034 int arg2 ;
23035 void *argp1 = 0 ;
23036 int res1 = 0 ;
23037 int val2 ;
23038 int ecode2 = 0 ;
23039 PyObject * obj0 = 0 ;
23040 PyObject * obj1 = 0 ;
23041 char * kwnames[] = {
23042 (char *) "self",(char *) "uniChar", NULL
23043 };
23044
23045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23049 }
23050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23051 ecode2 = SWIG_AsVal_int(obj1, &val2);
23052 if (!SWIG_IsOK(ecode2)) {
23053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23054 }
23055 arg2 = static_cast< int >(val2);
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 resultobj = SWIG_Py_Void();
23063 return resultobj;
23064 fail:
23065 return NULL;
23066 }
23067
23068
23069 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23070 PyObject *resultobj = 0;
23071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23072 unsigned int result;
23073 void *argp1 = 0 ;
23074 int res1 = 0 ;
23075 PyObject *swig_obj[1] ;
23076
23077 if (!args) SWIG_fail;
23078 swig_obj[0] = args;
23079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23080 if (!SWIG_IsOK(res1)) {
23081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23082 }
23083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23084 {
23085 PyThreadState* __tstate = wxPyBeginAllowThreads();
23086 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23100 unsigned int result;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 PyObject *swig_obj[1] ;
23104
23105 if (!args) SWIG_fail;
23106 swig_obj[0] = args;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23110 }
23111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23119 return resultobj;
23120 fail:
23121 return NULL;
23122 }
23123
23124
23125 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23126 PyObject *resultobj = 0;
23127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23128 wxPoint result;
23129 void *argp1 = 0 ;
23130 int res1 = 0 ;
23131 PyObject *swig_obj[1] ;
23132
23133 if (!args) SWIG_fail;
23134 swig_obj[0] = args;
23135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23138 }
23139 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23140 {
23141 PyThreadState* __tstate = wxPyBeginAllowThreads();
23142 result = (arg1)->GetPosition();
23143 wxPyEndAllowThreads(__tstate);
23144 if (PyErr_Occurred()) SWIG_fail;
23145 }
23146 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23147 return resultobj;
23148 fail:
23149 return NULL;
23150 }
23151
23152
23153 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23154 PyObject *resultobj = 0;
23155 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23156 long *arg2 = (long *) 0 ;
23157 long *arg3 = (long *) 0 ;
23158 void *argp1 = 0 ;
23159 int res1 = 0 ;
23160 long temp2 ;
23161 int res2 = SWIG_TMPOBJ ;
23162 long temp3 ;
23163 int res3 = SWIG_TMPOBJ ;
23164 PyObject *swig_obj[1] ;
23165
23166 arg2 = &temp2;
23167 arg3 = &temp3;
23168 if (!args) SWIG_fail;
23169 swig_obj[0] = args;
23170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23171 if (!SWIG_IsOK(res1)) {
23172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23173 }
23174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 (arg1)->GetPosition(arg2,arg3);
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 resultobj = SWIG_Py_Void();
23182 if (SWIG_IsTmpObj(res2)) {
23183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23184 } else {
23185 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23187 }
23188 if (SWIG_IsTmpObj(res3)) {
23189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23190 } else {
23191 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23193 }
23194 return resultobj;
23195 fail:
23196 return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23201 PyObject *resultobj = 0;
23202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23203 int result;
23204 void *argp1 = 0 ;
23205 int res1 = 0 ;
23206 PyObject *swig_obj[1] ;
23207
23208 if (!args) SWIG_fail;
23209 swig_obj[0] = args;
23210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23211 if (!SWIG_IsOK(res1)) {
23212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23213 }
23214 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (int)((wxKeyEvent const *)arg1)->GetX();
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_From_int(static_cast< int >(result));
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23231 int result;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 PyObject *swig_obj[1] ;
23235
23236 if (!args) SWIG_fail;
23237 swig_obj[0] = args;
23238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23241 }
23242 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (int)((wxKeyEvent const *)arg1)->GetY();
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_From_int(static_cast< int >(result));
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23257 PyObject *resultobj = 0;
23258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23259 int arg2 ;
23260 void *argp1 = 0 ;
23261 int res1 = 0 ;
23262 int val2 ;
23263 int ecode2 = 0 ;
23264 PyObject *swig_obj[2] ;
23265
23266 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23268 if (!SWIG_IsOK(res1)) {
23269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23270 }
23271 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23272 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23273 if (!SWIG_IsOK(ecode2)) {
23274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23275 }
23276 arg2 = static_cast< int >(val2);
23277 if (arg1) (arg1)->m_x = arg2;
23278
23279 resultobj = SWIG_Py_Void();
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23287 PyObject *resultobj = 0;
23288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23289 int result;
23290 void *argp1 = 0 ;
23291 int res1 = 0 ;
23292 PyObject *swig_obj[1] ;
23293
23294 if (!args) SWIG_fail;
23295 swig_obj[0] = args;
23296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23297 if (!SWIG_IsOK(res1)) {
23298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23299 }
23300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23301 result = (int) ((arg1)->m_x);
23302 resultobj = SWIG_From_int(static_cast< int >(result));
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23310 PyObject *resultobj = 0;
23311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23312 int arg2 ;
23313 void *argp1 = 0 ;
23314 int res1 = 0 ;
23315 int val2 ;
23316 int ecode2 = 0 ;
23317 PyObject *swig_obj[2] ;
23318
23319 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23321 if (!SWIG_IsOK(res1)) {
23322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23323 }
23324 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23325 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23326 if (!SWIG_IsOK(ecode2)) {
23327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23328 }
23329 arg2 = static_cast< int >(val2);
23330 if (arg1) (arg1)->m_y = arg2;
23331
23332 resultobj = SWIG_Py_Void();
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23340 PyObject *resultobj = 0;
23341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23342 int result;
23343 void *argp1 = 0 ;
23344 int res1 = 0 ;
23345 PyObject *swig_obj[1] ;
23346
23347 if (!args) SWIG_fail;
23348 swig_obj[0] = args;
23349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23350 if (!SWIG_IsOK(res1)) {
23351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23352 }
23353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23354 result = (int) ((arg1)->m_y);
23355 resultobj = SWIG_From_int(static_cast< int >(result));
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23363 PyObject *resultobj = 0;
23364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23365 long arg2 ;
23366 void *argp1 = 0 ;
23367 int res1 = 0 ;
23368 long val2 ;
23369 int ecode2 = 0 ;
23370 PyObject *swig_obj[2] ;
23371
23372 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23374 if (!SWIG_IsOK(res1)) {
23375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23376 }
23377 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23378 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23379 if (!SWIG_IsOK(ecode2)) {
23380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23381 }
23382 arg2 = static_cast< long >(val2);
23383 if (arg1) (arg1)->m_keyCode = arg2;
23384
23385 resultobj = SWIG_Py_Void();
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 PyObject *resultobj = 0;
23394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23395 long result;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 PyObject *swig_obj[1] ;
23399
23400 if (!args) SWIG_fail;
23401 swig_obj[0] = args;
23402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23403 if (!SWIG_IsOK(res1)) {
23404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23405 }
23406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23407 result = (long) ((arg1)->m_keyCode);
23408 resultobj = SWIG_From_long(static_cast< long >(result));
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 PyObject *resultobj = 0;
23417 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23418 bool arg2 ;
23419 void *argp1 = 0 ;
23420 int res1 = 0 ;
23421 bool val2 ;
23422 int ecode2 = 0 ;
23423 PyObject *swig_obj[2] ;
23424
23425 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23427 if (!SWIG_IsOK(res1)) {
23428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23429 }
23430 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23431 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23432 if (!SWIG_IsOK(ecode2)) {
23433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23434 }
23435 arg2 = static_cast< bool >(val2);
23436 if (arg1) (arg1)->m_controlDown = arg2;
23437
23438 resultobj = SWIG_Py_Void();
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23446 PyObject *resultobj = 0;
23447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23448 bool result;
23449 void *argp1 = 0 ;
23450 int res1 = 0 ;
23451 PyObject *swig_obj[1] ;
23452
23453 if (!args) SWIG_fail;
23454 swig_obj[0] = args;
23455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23456 if (!SWIG_IsOK(res1)) {
23457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23458 }
23459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23460 result = (bool) ((arg1)->m_controlDown);
23461 {
23462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23463 }
23464 return resultobj;
23465 fail:
23466 return NULL;
23467 }
23468
23469
23470 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23471 PyObject *resultobj = 0;
23472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23473 bool arg2 ;
23474 void *argp1 = 0 ;
23475 int res1 = 0 ;
23476 bool val2 ;
23477 int ecode2 = 0 ;
23478 PyObject *swig_obj[2] ;
23479
23480 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23484 }
23485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23486 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23487 if (!SWIG_IsOK(ecode2)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23489 }
23490 arg2 = static_cast< bool >(val2);
23491 if (arg1) (arg1)->m_shiftDown = arg2;
23492
23493 resultobj = SWIG_Py_Void();
23494 return resultobj;
23495 fail:
23496 return NULL;
23497 }
23498
23499
23500 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23501 PyObject *resultobj = 0;
23502 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23503 bool result;
23504 void *argp1 = 0 ;
23505 int res1 = 0 ;
23506 PyObject *swig_obj[1] ;
23507
23508 if (!args) SWIG_fail;
23509 swig_obj[0] = args;
23510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23511 if (!SWIG_IsOK(res1)) {
23512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23513 }
23514 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23515 result = (bool) ((arg1)->m_shiftDown);
23516 {
23517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23518 }
23519 return resultobj;
23520 fail:
23521 return NULL;
23522 }
23523
23524
23525 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23526 PyObject *resultobj = 0;
23527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23528 bool arg2 ;
23529 void *argp1 = 0 ;
23530 int res1 = 0 ;
23531 bool val2 ;
23532 int ecode2 = 0 ;
23533 PyObject *swig_obj[2] ;
23534
23535 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23537 if (!SWIG_IsOK(res1)) {
23538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23539 }
23540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23541 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23542 if (!SWIG_IsOK(ecode2)) {
23543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23544 }
23545 arg2 = static_cast< bool >(val2);
23546 if (arg1) (arg1)->m_altDown = arg2;
23547
23548 resultobj = SWIG_Py_Void();
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 PyObject *resultobj = 0;
23557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23558 bool result;
23559 void *argp1 = 0 ;
23560 int res1 = 0 ;
23561 PyObject *swig_obj[1] ;
23562
23563 if (!args) SWIG_fail;
23564 swig_obj[0] = args;
23565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23566 if (!SWIG_IsOK(res1)) {
23567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23568 }
23569 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23570 result = (bool) ((arg1)->m_altDown);
23571 {
23572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23573 }
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23581 PyObject *resultobj = 0;
23582 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23583 bool arg2 ;
23584 void *argp1 = 0 ;
23585 int res1 = 0 ;
23586 bool val2 ;
23587 int ecode2 = 0 ;
23588 PyObject *swig_obj[2] ;
23589
23590 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23592 if (!SWIG_IsOK(res1)) {
23593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23594 }
23595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23596 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23597 if (!SWIG_IsOK(ecode2)) {
23598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23599 }
23600 arg2 = static_cast< bool >(val2);
23601 if (arg1) (arg1)->m_metaDown = arg2;
23602
23603 resultobj = SWIG_Py_Void();
23604 return resultobj;
23605 fail:
23606 return NULL;
23607 }
23608
23609
23610 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23611 PyObject *resultobj = 0;
23612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23613 bool result;
23614 void *argp1 = 0 ;
23615 int res1 = 0 ;
23616 PyObject *swig_obj[1] ;
23617
23618 if (!args) SWIG_fail;
23619 swig_obj[0] = args;
23620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23621 if (!SWIG_IsOK(res1)) {
23622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23623 }
23624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23625 result = (bool) ((arg1)->m_metaDown);
23626 {
23627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23628 }
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23636 PyObject *resultobj = 0;
23637 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23638 bool arg2 ;
23639 void *argp1 = 0 ;
23640 int res1 = 0 ;
23641 bool val2 ;
23642 int ecode2 = 0 ;
23643 PyObject *swig_obj[2] ;
23644
23645 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23649 }
23650 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23651 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23652 if (!SWIG_IsOK(ecode2)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23654 }
23655 arg2 = static_cast< bool >(val2);
23656 if (arg1) (arg1)->m_scanCode = arg2;
23657
23658 resultobj = SWIG_Py_Void();
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 PyObject *resultobj = 0;
23667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23668 bool result;
23669 void *argp1 = 0 ;
23670 int res1 = 0 ;
23671 PyObject *swig_obj[1] ;
23672
23673 if (!args) SWIG_fail;
23674 swig_obj[0] = args;
23675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23676 if (!SWIG_IsOK(res1)) {
23677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23678 }
23679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23680 result = (bool) ((arg1)->m_scanCode);
23681 {
23682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23683 }
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23691 PyObject *resultobj = 0;
23692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23693 unsigned int arg2 ;
23694 void *argp1 = 0 ;
23695 int res1 = 0 ;
23696 unsigned int val2 ;
23697 int ecode2 = 0 ;
23698 PyObject *swig_obj[2] ;
23699
23700 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23702 if (!SWIG_IsOK(res1)) {
23703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23704 }
23705 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23706 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23707 if (!SWIG_IsOK(ecode2)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23709 }
23710 arg2 = static_cast< unsigned int >(val2);
23711 if (arg1) (arg1)->m_rawCode = arg2;
23712
23713 resultobj = SWIG_Py_Void();
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 PyObject *resultobj = 0;
23722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23723 unsigned int result;
23724 void *argp1 = 0 ;
23725 int res1 = 0 ;
23726 PyObject *swig_obj[1] ;
23727
23728 if (!args) SWIG_fail;
23729 swig_obj[0] = args;
23730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23731 if (!SWIG_IsOK(res1)) {
23732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23733 }
23734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23735 result = (unsigned int) ((arg1)->m_rawCode);
23736 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23744 PyObject *resultobj = 0;
23745 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23746 unsigned int arg2 ;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 unsigned int val2 ;
23750 int ecode2 = 0 ;
23751 PyObject *swig_obj[2] ;
23752
23753 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23755 if (!SWIG_IsOK(res1)) {
23756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23757 }
23758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23759 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23760 if (!SWIG_IsOK(ecode2)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23762 }
23763 arg2 = static_cast< unsigned int >(val2);
23764 if (arg1) (arg1)->m_rawFlags = arg2;
23765
23766 resultobj = SWIG_Py_Void();
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23774 PyObject *resultobj = 0;
23775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23776 unsigned int result;
23777 void *argp1 = 0 ;
23778 int res1 = 0 ;
23779 PyObject *swig_obj[1] ;
23780
23781 if (!args) SWIG_fail;
23782 swig_obj[0] = args;
23783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23786 }
23787 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23788 result = (unsigned int) ((arg1)->m_rawFlags);
23789 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *obj;
23798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23799 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23800 return SWIG_Py_Void();
23801 }
23802
23803 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23804 return SWIG_Python_InitShadowInstance(args);
23805 }
23806
23807 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23808 PyObject *resultobj = 0;
23809 wxSize const &arg1_defvalue = wxDefaultSize ;
23810 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23811 int arg2 = (int) 0 ;
23812 wxSizeEvent *result = 0 ;
23813 wxSize temp1 ;
23814 int val2 ;
23815 int ecode2 = 0 ;
23816 PyObject * obj0 = 0 ;
23817 PyObject * obj1 = 0 ;
23818 char * kwnames[] = {
23819 (char *) "sz",(char *) "winid", NULL
23820 };
23821
23822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23823 if (obj0) {
23824 {
23825 arg1 = &temp1;
23826 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23827 }
23828 }
23829 if (obj1) {
23830 ecode2 = SWIG_AsVal_int(obj1, &val2);
23831 if (!SWIG_IsOK(ecode2)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23833 }
23834 arg2 = static_cast< int >(val2);
23835 }
23836 {
23837 PyThreadState* __tstate = wxPyBeginAllowThreads();
23838 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23850 PyObject *resultobj = 0;
23851 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23852 wxSize result;
23853 void *argp1 = 0 ;
23854 int res1 = 0 ;
23855 PyObject *swig_obj[1] ;
23856
23857 if (!args) SWIG_fail;
23858 swig_obj[0] = args;
23859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23860 if (!SWIG_IsOK(res1)) {
23861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23862 }
23863 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23864 {
23865 PyThreadState* __tstate = wxPyBeginAllowThreads();
23866 result = ((wxSizeEvent const *)arg1)->GetSize();
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23871 return resultobj;
23872 fail:
23873 return NULL;
23874 }
23875
23876
23877 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23878 PyObject *resultobj = 0;
23879 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23880 wxRect result;
23881 void *argp1 = 0 ;
23882 int res1 = 0 ;
23883 PyObject *swig_obj[1] ;
23884
23885 if (!args) SWIG_fail;
23886 swig_obj[0] = args;
23887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23888 if (!SWIG_IsOK(res1)) {
23889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23890 }
23891 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = ((wxSizeEvent const *)arg1)->GetRect();
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj = 0;
23907 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23908 wxRect arg2 ;
23909 void *argp1 = 0 ;
23910 int res1 = 0 ;
23911 void *argp2 ;
23912 int res2 = 0 ;
23913 PyObject * obj0 = 0 ;
23914 PyObject * obj1 = 0 ;
23915 char * kwnames[] = {
23916 (char *) "self",(char *) "rect", NULL
23917 };
23918
23919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23921 if (!SWIG_IsOK(res1)) {
23922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23923 }
23924 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23925 {
23926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23927 if (!SWIG_IsOK(res2)) {
23928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23929 }
23930 if (!argp2) {
23931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23932 } else {
23933 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23934 arg2 = *temp;
23935 if (SWIG_IsNewObj(res2)) delete temp;
23936 }
23937 }
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 (arg1)->SetRect(arg2);
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_Py_Void();
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = 0;
23953 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23954 wxSize arg2 ;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 void *argp2 ;
23958 int res2 = 0 ;
23959 PyObject * obj0 = 0 ;
23960 PyObject * obj1 = 0 ;
23961 char * kwnames[] = {
23962 (char *) "self",(char *) "size", NULL
23963 };
23964
23965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23967 if (!SWIG_IsOK(res1)) {
23968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23969 }
23970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23971 {
23972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23973 if (!SWIG_IsOK(res2)) {
23974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23975 }
23976 if (!argp2) {
23977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23978 } else {
23979 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23980 arg2 = *temp;
23981 if (SWIG_IsNewObj(res2)) delete temp;
23982 }
23983 }
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 wxSizeEvent_SetSize(arg1,arg2);
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 resultobj = SWIG_Py_Void();
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 PyObject *resultobj = 0;
23999 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24000 wxSize *arg2 = (wxSize *) 0 ;
24001 void *argp1 = 0 ;
24002 int res1 = 0 ;
24003 void *argp2 = 0 ;
24004 int res2 = 0 ;
24005 PyObject *swig_obj[2] ;
24006
24007 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24009 if (!SWIG_IsOK(res1)) {
24010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24011 }
24012 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24013 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24014 if (!SWIG_IsOK(res2)) {
24015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24016 }
24017 arg2 = reinterpret_cast< wxSize * >(argp2);
24018 if (arg1) (arg1)->m_size = *arg2;
24019
24020 resultobj = SWIG_Py_Void();
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24028 PyObject *resultobj = 0;
24029 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24030 wxSize *result = 0 ;
24031 void *argp1 = 0 ;
24032 int res1 = 0 ;
24033 PyObject *swig_obj[1] ;
24034
24035 if (!args) SWIG_fail;
24036 swig_obj[0] = args;
24037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24038 if (!SWIG_IsOK(res1)) {
24039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24040 }
24041 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24042 result = (wxSize *)& ((arg1)->m_size);
24043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24051 PyObject *resultobj = 0;
24052 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24053 wxRect *arg2 = (wxRect *) 0 ;
24054 void *argp1 = 0 ;
24055 int res1 = 0 ;
24056 void *argp2 = 0 ;
24057 int res2 = 0 ;
24058 PyObject *swig_obj[2] ;
24059
24060 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24062 if (!SWIG_IsOK(res1)) {
24063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24064 }
24065 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24066 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24067 if (!SWIG_IsOK(res2)) {
24068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24069 }
24070 arg2 = reinterpret_cast< wxRect * >(argp2);
24071 if (arg1) (arg1)->m_rect = *arg2;
24072
24073 resultobj = SWIG_Py_Void();
24074 return resultobj;
24075 fail:
24076 return NULL;
24077 }
24078
24079
24080 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24081 PyObject *resultobj = 0;
24082 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24083 wxRect *result = 0 ;
24084 void *argp1 = 0 ;
24085 int res1 = 0 ;
24086 PyObject *swig_obj[1] ;
24087
24088 if (!args) SWIG_fail;
24089 swig_obj[0] = args;
24090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24091 if (!SWIG_IsOK(res1)) {
24092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24093 }
24094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24095 result = (wxRect *)& ((arg1)->m_rect);
24096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24104 PyObject *obj;
24105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24106 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24107 return SWIG_Py_Void();
24108 }
24109
24110 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24111 return SWIG_Python_InitShadowInstance(args);
24112 }
24113
24114 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj = 0;
24116 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24117 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24118 int arg2 = (int) 0 ;
24119 wxMoveEvent *result = 0 ;
24120 wxPoint temp1 ;
24121 int val2 ;
24122 int ecode2 = 0 ;
24123 PyObject * obj0 = 0 ;
24124 PyObject * obj1 = 0 ;
24125 char * kwnames[] = {
24126 (char *) "pos",(char *) "winid", NULL
24127 };
24128
24129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24130 if (obj0) {
24131 {
24132 arg1 = &temp1;
24133 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24134 }
24135 }
24136 if (obj1) {
24137 ecode2 = SWIG_AsVal_int(obj1, &val2);
24138 if (!SWIG_IsOK(ecode2)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24140 }
24141 arg2 = static_cast< int >(val2);
24142 }
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24157 PyObject *resultobj = 0;
24158 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24159 wxPoint result;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 PyObject *swig_obj[1] ;
24163
24164 if (!args) SWIG_fail;
24165 swig_obj[0] = args;
24166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24167 if (!SWIG_IsOK(res1)) {
24168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24169 }
24170 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 result = ((wxMoveEvent const *)arg1)->GetPosition();
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24187 wxRect result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = ((wxMoveEvent const *)arg1)->GetRect();
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = 0;
24214 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24215 wxRect *arg2 = 0 ;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 wxRect temp2 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "rect", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24231 {
24232 arg2 = &temp2;
24233 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24234 }
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 (arg1)->SetRect((wxRect const &)*arg2);
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 resultobj = SWIG_Py_Void();
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24249 PyObject *resultobj = 0;
24250 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24251 wxPoint *arg2 = 0 ;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 wxPoint temp2 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char * kwnames[] = {
24258 (char *) "self",(char *) "pos", NULL
24259 };
24260
24261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24265 }
24266 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24267 {
24268 arg2 = &temp2;
24269 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24270 }
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 (arg1)->SetPosition((wxPoint const &)*arg2);
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 resultobj = SWIG_Py_Void();
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24285 PyObject *obj;
24286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24287 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24288 return SWIG_Py_Void();
24289 }
24290
24291 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24292 return SWIG_Python_InitShadowInstance(args);
24293 }
24294
24295 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = 0;
24297 int arg1 = (int) 0 ;
24298 wxPaintEvent *result = 0 ;
24299 int val1 ;
24300 int ecode1 = 0 ;
24301 PyObject * obj0 = 0 ;
24302 char * kwnames[] = {
24303 (char *) "Id", NULL
24304 };
24305
24306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24307 if (obj0) {
24308 ecode1 = SWIG_AsVal_int(obj0, &val1);
24309 if (!SWIG_IsOK(ecode1)) {
24310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24311 }
24312 arg1 = static_cast< int >(val1);
24313 }
24314 {
24315 PyThreadState* __tstate = wxPyBeginAllowThreads();
24316 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24328 PyObject *obj;
24329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24330 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24331 return SWIG_Py_Void();
24332 }
24333
24334 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 return SWIG_Python_InitShadowInstance(args);
24336 }
24337
24338 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj = 0;
24340 int arg1 = (int) 0 ;
24341 wxNcPaintEvent *result = 0 ;
24342 int val1 ;
24343 int ecode1 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "winid", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24350 if (obj0) {
24351 ecode1 = SWIG_AsVal_int(obj0, &val1);
24352 if (!SWIG_IsOK(ecode1)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24354 }
24355 arg1 = static_cast< int >(val1);
24356 }
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24371 PyObject *obj;
24372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24373 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24374 return SWIG_Py_Void();
24375 }
24376
24377 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24378 return SWIG_Python_InitShadowInstance(args);
24379 }
24380
24381 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24382 PyObject *resultobj = 0;
24383 int arg1 = (int) 0 ;
24384 wxDC *arg2 = (wxDC *) NULL ;
24385 wxEraseEvent *result = 0 ;
24386 int val1 ;
24387 int ecode1 = 0 ;
24388 void *argp2 = 0 ;
24389 int res2 = 0 ;
24390 PyObject * obj0 = 0 ;
24391 PyObject * obj1 = 0 ;
24392 char * kwnames[] = {
24393 (char *) "Id",(char *) "dc", NULL
24394 };
24395
24396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24397 if (obj0) {
24398 ecode1 = SWIG_AsVal_int(obj0, &val1);
24399 if (!SWIG_IsOK(ecode1)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24401 }
24402 arg1 = static_cast< int >(val1);
24403 }
24404 if (obj1) {
24405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24406 if (!SWIG_IsOK(res2)) {
24407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24408 }
24409 arg2 = reinterpret_cast< wxDC * >(argp2);
24410 }
24411 {
24412 PyThreadState* __tstate = wxPyBeginAllowThreads();
24413 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24425 PyObject *resultobj = 0;
24426 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24427 wxDC *result = 0 ;
24428 void *argp1 = 0 ;
24429 int res1 = 0 ;
24430 PyObject *swig_obj[1] ;
24431
24432 if (!args) SWIG_fail;
24433 swig_obj[0] = args;
24434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24435 if (!SWIG_IsOK(res1)) {
24436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24437 }
24438 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24439 {
24440 PyThreadState* __tstate = wxPyBeginAllowThreads();
24441 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 {
24446 resultobj = wxPyMake_wxObject(result, (bool)0);
24447 }
24448 return resultobj;
24449 fail:
24450 return NULL;
24451 }
24452
24453
24454 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 PyObject *obj;
24456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24457 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24458 return SWIG_Py_Void();
24459 }
24460
24461 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 return SWIG_Python_InitShadowInstance(args);
24463 }
24464
24465 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24466 PyObject *resultobj = 0;
24467 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24468 int arg2 = (int) 0 ;
24469 wxFocusEvent *result = 0 ;
24470 int val1 ;
24471 int ecode1 = 0 ;
24472 int val2 ;
24473 int ecode2 = 0 ;
24474 PyObject * obj0 = 0 ;
24475 PyObject * obj1 = 0 ;
24476 char * kwnames[] = {
24477 (char *) "type",(char *) "winid", NULL
24478 };
24479
24480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24481 if (obj0) {
24482 ecode1 = SWIG_AsVal_int(obj0, &val1);
24483 if (!SWIG_IsOK(ecode1)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24485 }
24486 arg1 = static_cast< wxEventType >(val1);
24487 }
24488 if (obj1) {
24489 ecode2 = SWIG_AsVal_int(obj1, &val2);
24490 if (!SWIG_IsOK(ecode2)) {
24491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24492 }
24493 arg2 = static_cast< int >(val2);
24494 }
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24509 PyObject *resultobj = 0;
24510 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24511 wxWindow *result = 0 ;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 PyObject *swig_obj[1] ;
24515
24516 if (!args) SWIG_fail;
24517 swig_obj[0] = args;
24518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24519 if (!SWIG_IsOK(res1)) {
24520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24521 }
24522 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = wxPyMake_wxObject(result, (bool)0);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = 0;
24540 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24541 wxWindow *arg2 = (wxWindow *) 0 ;
24542 void *argp1 = 0 ;
24543 int res1 = 0 ;
24544 void *argp2 = 0 ;
24545 int res2 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 char * kwnames[] = {
24549 (char *) "self",(char *) "win", NULL
24550 };
24551
24552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24554 if (!SWIG_IsOK(res1)) {
24555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24556 }
24557 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24559 if (!SWIG_IsOK(res2)) {
24560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24561 }
24562 arg2 = reinterpret_cast< wxWindow * >(argp2);
24563 {
24564 PyThreadState* __tstate = wxPyBeginAllowThreads();
24565 (arg1)->SetWindow(arg2);
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 resultobj = SWIG_Py_Void();
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24577 PyObject *obj;
24578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24579 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24580 return SWIG_Py_Void();
24581 }
24582
24583 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24584 return SWIG_Python_InitShadowInstance(args);
24585 }
24586
24587 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj = 0;
24589 wxWindow *arg1 = (wxWindow *) NULL ;
24590 wxChildFocusEvent *result = 0 ;
24591 void *argp1 = 0 ;
24592 int res1 = 0 ;
24593 PyObject * obj0 = 0 ;
24594 char * kwnames[] = {
24595 (char *) "win", NULL
24596 };
24597
24598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24599 if (obj0) {
24600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24601 if (!SWIG_IsOK(res1)) {
24602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24603 }
24604 arg1 = reinterpret_cast< wxWindow * >(argp1);
24605 }
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24609 wxPyEndAllowThreads(__tstate);
24610 if (PyErr_Occurred()) SWIG_fail;
24611 }
24612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24620 PyObject *resultobj = 0;
24621 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24622 wxWindow *result = 0 ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 PyObject *swig_obj[1] ;
24626
24627 if (!args) SWIG_fail;
24628 swig_obj[0] = args;
24629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24630 if (!SWIG_IsOK(res1)) {
24631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24632 }
24633 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 {
24641 resultobj = wxPyMake_wxObject(result, (bool)0);
24642 }
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24650 PyObject *obj;
24651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24652 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24653 return SWIG_Py_Void();
24654 }
24655
24656 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24657 return SWIG_Python_InitShadowInstance(args);
24658 }
24659
24660 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24663 bool arg2 = (bool) true ;
24664 int arg3 = (int) 0 ;
24665 wxActivateEvent *result = 0 ;
24666 int val1 ;
24667 int ecode1 = 0 ;
24668 bool val2 ;
24669 int ecode2 = 0 ;
24670 int val3 ;
24671 int ecode3 = 0 ;
24672 PyObject * obj0 = 0 ;
24673 PyObject * obj1 = 0 ;
24674 PyObject * obj2 = 0 ;
24675 char * kwnames[] = {
24676 (char *) "type",(char *) "active",(char *) "Id", NULL
24677 };
24678
24679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24680 if (obj0) {
24681 ecode1 = SWIG_AsVal_int(obj0, &val1);
24682 if (!SWIG_IsOK(ecode1)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24684 }
24685 arg1 = static_cast< wxEventType >(val1);
24686 }
24687 if (obj1) {
24688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24689 if (!SWIG_IsOK(ecode2)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24691 }
24692 arg2 = static_cast< bool >(val2);
24693 }
24694 if (obj2) {
24695 ecode3 = SWIG_AsVal_int(obj2, &val3);
24696 if (!SWIG_IsOK(ecode3)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24698 }
24699 arg3 = static_cast< int >(val3);
24700 }
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24715 PyObject *resultobj = 0;
24716 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24717 bool result;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 PyObject *swig_obj[1] ;
24721
24722 if (!args) SWIG_fail;
24723 swig_obj[0] = args;
24724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24725 if (!SWIG_IsOK(res1)) {
24726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24727 }
24728 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 {
24736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24745 PyObject *obj;
24746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24747 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24748 return SWIG_Py_Void();
24749 }
24750
24751 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 return SWIG_Python_InitShadowInstance(args);
24753 }
24754
24755 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 int arg1 = (int) 0 ;
24758 wxInitDialogEvent *result = 0 ;
24759 int val1 ;
24760 int ecode1 = 0 ;
24761 PyObject * obj0 = 0 ;
24762 char * kwnames[] = {
24763 (char *) "Id", NULL
24764 };
24765
24766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24767 if (obj0) {
24768 ecode1 = SWIG_AsVal_int(obj0, &val1);
24769 if (!SWIG_IsOK(ecode1)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24771 }
24772 arg1 = static_cast< int >(val1);
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24777 wxPyEndAllowThreads(__tstate);
24778 if (PyErr_Occurred()) SWIG_fail;
24779 }
24780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24788 PyObject *obj;
24789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24790 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24791 return SWIG_Py_Void();
24792 }
24793
24794 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24795 return SWIG_Python_InitShadowInstance(args);
24796 }
24797
24798 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24799 PyObject *resultobj = 0;
24800 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24801 int arg2 = (int) 0 ;
24802 wxMenu *arg3 = (wxMenu *) NULL ;
24803 wxMenuEvent *result = 0 ;
24804 int val1 ;
24805 int ecode1 = 0 ;
24806 int val2 ;
24807 int ecode2 = 0 ;
24808 void *argp3 = 0 ;
24809 int res3 = 0 ;
24810 PyObject * obj0 = 0 ;
24811 PyObject * obj1 = 0 ;
24812 PyObject * obj2 = 0 ;
24813 char * kwnames[] = {
24814 (char *) "type",(char *) "winid",(char *) "menu", NULL
24815 };
24816
24817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24818 if (obj0) {
24819 ecode1 = SWIG_AsVal_int(obj0, &val1);
24820 if (!SWIG_IsOK(ecode1)) {
24821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24822 }
24823 arg1 = static_cast< wxEventType >(val1);
24824 }
24825 if (obj1) {
24826 ecode2 = SWIG_AsVal_int(obj1, &val2);
24827 if (!SWIG_IsOK(ecode2)) {
24828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24829 }
24830 arg2 = static_cast< int >(val2);
24831 }
24832 if (obj2) {
24833 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24834 if (!SWIG_IsOK(res3)) {
24835 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24836 }
24837 arg3 = reinterpret_cast< wxMenu * >(argp3);
24838 }
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24853 PyObject *resultobj = 0;
24854 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24855 int result;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 PyObject *swig_obj[1] ;
24859
24860 if (!args) SWIG_fail;
24861 swig_obj[0] = args;
24862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24863 if (!SWIG_IsOK(res1)) {
24864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24865 }
24866 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_From_int(static_cast< int >(result));
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24883 bool result;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 PyObject *swig_obj[1] ;
24887
24888 if (!args) SWIG_fail;
24889 swig_obj[0] = args;
24890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24893 }
24894 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24898 wxPyEndAllowThreads(__tstate);
24899 if (PyErr_Occurred()) SWIG_fail;
24900 }
24901 {
24902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24903 }
24904 return resultobj;
24905 fail:
24906 return NULL;
24907 }
24908
24909
24910 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24911 PyObject *resultobj = 0;
24912 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24913 wxMenu *result = 0 ;
24914 void *argp1 = 0 ;
24915 int res1 = 0 ;
24916 PyObject *swig_obj[1] ;
24917
24918 if (!args) SWIG_fail;
24919 swig_obj[0] = args;
24920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24921 if (!SWIG_IsOK(res1)) {
24922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24923 }
24924 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24928 wxPyEndAllowThreads(__tstate);
24929 if (PyErr_Occurred()) SWIG_fail;
24930 }
24931 {
24932 resultobj = wxPyMake_wxObject(result, (bool)0);
24933 }
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24941 PyObject *obj;
24942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24943 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24944 return SWIG_Py_Void();
24945 }
24946
24947 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24948 return SWIG_Python_InitShadowInstance(args);
24949 }
24950
24951 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj = 0;
24953 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24954 int arg2 = (int) 0 ;
24955 wxCloseEvent *result = 0 ;
24956 int val1 ;
24957 int ecode1 = 0 ;
24958 int val2 ;
24959 int ecode2 = 0 ;
24960 PyObject * obj0 = 0 ;
24961 PyObject * obj1 = 0 ;
24962 char * kwnames[] = {
24963 (char *) "type",(char *) "winid", NULL
24964 };
24965
24966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24967 if (obj0) {
24968 ecode1 = SWIG_AsVal_int(obj0, &val1);
24969 if (!SWIG_IsOK(ecode1)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24971 }
24972 arg1 = static_cast< wxEventType >(val1);
24973 }
24974 if (obj1) {
24975 ecode2 = SWIG_AsVal_int(obj1, &val2);
24976 if (!SWIG_IsOK(ecode2)) {
24977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24978 }
24979 arg2 = static_cast< int >(val2);
24980 }
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj = 0;
24996 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24997 bool arg2 ;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 bool val2 ;
25001 int ecode2 = 0 ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 char * kwnames[] = {
25005 (char *) "self",(char *) "logOff", NULL
25006 };
25007
25008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25012 }
25013 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25014 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25015 if (!SWIG_IsOK(ecode2)) {
25016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25017 }
25018 arg2 = static_cast< bool >(val2);
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 (arg1)->SetLoggingOff(arg2);
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 resultobj = SWIG_Py_Void();
25026 return resultobj;
25027 fail:
25028 return NULL;
25029 }
25030
25031
25032 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25033 PyObject *resultobj = 0;
25034 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25035 bool result;
25036 void *argp1 = 0 ;
25037 int res1 = 0 ;
25038 PyObject *swig_obj[1] ;
25039
25040 if (!args) SWIG_fail;
25041 swig_obj[0] = args;
25042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25043 if (!SWIG_IsOK(res1)) {
25044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25045 }
25046 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 {
25054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25055 }
25056 return resultobj;
25057 fail:
25058 return NULL;
25059 }
25060
25061
25062 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25063 PyObject *resultobj = 0;
25064 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25065 bool arg2 = (bool) true ;
25066 void *argp1 = 0 ;
25067 int res1 = 0 ;
25068 bool val2 ;
25069 int ecode2 = 0 ;
25070 PyObject * obj0 = 0 ;
25071 PyObject * obj1 = 0 ;
25072 char * kwnames[] = {
25073 (char *) "self",(char *) "veto", NULL
25074 };
25075
25076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25078 if (!SWIG_IsOK(res1)) {
25079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25080 }
25081 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25082 if (obj1) {
25083 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25084 if (!SWIG_IsOK(ecode2)) {
25085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25086 }
25087 arg2 = static_cast< bool >(val2);
25088 }
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 (arg1)->Veto(arg2);
25092 wxPyEndAllowThreads(__tstate);
25093 if (PyErr_Occurred()) SWIG_fail;
25094 }
25095 resultobj = SWIG_Py_Void();
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25103 PyObject *resultobj = 0;
25104 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25105 bool result;
25106 void *argp1 = 0 ;
25107 int res1 = 0 ;
25108 PyObject *swig_obj[1] ;
25109
25110 if (!args) SWIG_fail;
25111 swig_obj[0] = args;
25112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25115 }
25116 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25125 }
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25133 PyObject *resultobj = 0;
25134 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25135 bool arg2 ;
25136 void *argp1 = 0 ;
25137 int res1 = 0 ;
25138 bool val2 ;
25139 int ecode2 = 0 ;
25140 PyObject * obj0 = 0 ;
25141 PyObject * obj1 = 0 ;
25142 char * kwnames[] = {
25143 (char *) "self",(char *) "canVeto", NULL
25144 };
25145
25146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25148 if (!SWIG_IsOK(res1)) {
25149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25150 }
25151 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25152 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25153 if (!SWIG_IsOK(ecode2)) {
25154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25155 }
25156 arg2 = static_cast< bool >(val2);
25157 {
25158 PyThreadState* __tstate = wxPyBeginAllowThreads();
25159 (arg1)->SetCanVeto(arg2);
25160 wxPyEndAllowThreads(__tstate);
25161 if (PyErr_Occurred()) SWIG_fail;
25162 }
25163 resultobj = SWIG_Py_Void();
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25171 PyObject *resultobj = 0;
25172 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25173 bool result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 PyObject *swig_obj[1] ;
25177
25178 if (!args) SWIG_fail;
25179 swig_obj[0] = args;
25180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25181 if (!SWIG_IsOK(res1)) {
25182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25183 }
25184 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 {
25192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25193 }
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 PyObject *obj;
25202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25203 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25204 return SWIG_Py_Void();
25205 }
25206
25207 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25208 return SWIG_Python_InitShadowInstance(args);
25209 }
25210
25211 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25212 PyObject *resultobj = 0;
25213 int arg1 = (int) 0 ;
25214 bool arg2 = (bool) false ;
25215 wxShowEvent *result = 0 ;
25216 int val1 ;
25217 int ecode1 = 0 ;
25218 bool val2 ;
25219 int ecode2 = 0 ;
25220 PyObject * obj0 = 0 ;
25221 PyObject * obj1 = 0 ;
25222 char * kwnames[] = {
25223 (char *) "winid",(char *) "show", NULL
25224 };
25225
25226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25227 if (obj0) {
25228 ecode1 = SWIG_AsVal_int(obj0, &val1);
25229 if (!SWIG_IsOK(ecode1)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25231 }
25232 arg1 = static_cast< int >(val1);
25233 }
25234 if (obj1) {
25235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25236 if (!SWIG_IsOK(ecode2)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25238 }
25239 arg2 = static_cast< bool >(val2);
25240 }
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = 0;
25256 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25257 bool arg2 ;
25258 void *argp1 = 0 ;
25259 int res1 = 0 ;
25260 bool val2 ;
25261 int ecode2 = 0 ;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 char * kwnames[] = {
25265 (char *) "self",(char *) "show", NULL
25266 };
25267
25268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25270 if (!SWIG_IsOK(res1)) {
25271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25272 }
25273 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25275 if (!SWIG_IsOK(ecode2)) {
25276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25277 }
25278 arg2 = static_cast< bool >(val2);
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 (arg1)->SetShow(arg2);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_Py_Void();
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25293 PyObject *resultobj = 0;
25294 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25295 bool result;
25296 void *argp1 = 0 ;
25297 int res1 = 0 ;
25298 PyObject *swig_obj[1] ;
25299
25300 if (!args) SWIG_fail;
25301 swig_obj[0] = args;
25302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25303 if (!SWIG_IsOK(res1)) {
25304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25305 }
25306 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 {
25314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *obj;
25324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25325 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25326 return SWIG_Py_Void();
25327 }
25328
25329 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25330 return SWIG_Python_InitShadowInstance(args);
25331 }
25332
25333 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25334 PyObject *resultobj = 0;
25335 int arg1 = (int) 0 ;
25336 bool arg2 = (bool) true ;
25337 wxIconizeEvent *result = 0 ;
25338 int val1 ;
25339 int ecode1 = 0 ;
25340 bool val2 ;
25341 int ecode2 = 0 ;
25342 PyObject * obj0 = 0 ;
25343 PyObject * obj1 = 0 ;
25344 char * kwnames[] = {
25345 (char *) "id",(char *) "iconized", NULL
25346 };
25347
25348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25349 if (obj0) {
25350 ecode1 = SWIG_AsVal_int(obj0, &val1);
25351 if (!SWIG_IsOK(ecode1)) {
25352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25353 }
25354 arg1 = static_cast< int >(val1);
25355 }
25356 if (obj1) {
25357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25358 if (!SWIG_IsOK(ecode2)) {
25359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25360 }
25361 arg2 = static_cast< bool >(val2);
25362 }
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377 PyObject *resultobj = 0;
25378 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25379 bool result;
25380 void *argp1 = 0 ;
25381 int res1 = 0 ;
25382 PyObject *swig_obj[1] ;
25383
25384 if (!args) SWIG_fail;
25385 swig_obj[0] = args;
25386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25387 if (!SWIG_IsOK(res1)) {
25388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25389 }
25390 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 result = (bool)(arg1)->Iconized();
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25399 }
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25407 PyObject *obj;
25408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25409 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25410 return SWIG_Py_Void();
25411 }
25412
25413 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25414 return SWIG_Python_InitShadowInstance(args);
25415 }
25416
25417 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25418 PyObject *resultobj = 0;
25419 int arg1 = (int) 0 ;
25420 wxMaximizeEvent *result = 0 ;
25421 int val1 ;
25422 int ecode1 = 0 ;
25423 PyObject * obj0 = 0 ;
25424 char * kwnames[] = {
25425 (char *) "id", NULL
25426 };
25427
25428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25429 if (obj0) {
25430 ecode1 = SWIG_AsVal_int(obj0, &val1);
25431 if (!SWIG_IsOK(ecode1)) {
25432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25433 }
25434 arg1 = static_cast< int >(val1);
25435 }
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *obj;
25451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25452 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25453 return SWIG_Py_Void();
25454 }
25455
25456 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 return SWIG_Python_InitShadowInstance(args);
25458 }
25459
25460 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25461 PyObject *resultobj = 0;
25462 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25463 wxPoint result;
25464 void *argp1 = 0 ;
25465 int res1 = 0 ;
25466 PyObject *swig_obj[1] ;
25467
25468 if (!args) SWIG_fail;
25469 swig_obj[0] = args;
25470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25471 if (!SWIG_IsOK(res1)) {
25472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25473 }
25474 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = (arg1)->GetPosition();
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25489 PyObject *resultobj = 0;
25490 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25491 int result;
25492 void *argp1 = 0 ;
25493 int res1 = 0 ;
25494 PyObject *swig_obj[1] ;
25495
25496 if (!args) SWIG_fail;
25497 swig_obj[0] = args;
25498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = (int)(arg1)->GetNumberOfFiles();
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 resultobj = SWIG_From_int(static_cast< int >(result));
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25517 PyObject *resultobj = 0;
25518 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25519 PyObject *result = 0 ;
25520 void *argp1 = 0 ;
25521 int res1 = 0 ;
25522 PyObject *swig_obj[1] ;
25523
25524 if (!args) SWIG_fail;
25525 swig_obj[0] = args;
25526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25527 if (!SWIG_IsOK(res1)) {
25528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25529 }
25530 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 resultobj = result;
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25545 PyObject *obj;
25546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25547 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25548 return SWIG_Py_Void();
25549 }
25550
25551 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25552 PyObject *resultobj = 0;
25553 int arg1 = (int) 0 ;
25554 wxUpdateUIEvent *result = 0 ;
25555 int val1 ;
25556 int ecode1 = 0 ;
25557 PyObject * obj0 = 0 ;
25558 char * kwnames[] = {
25559 (char *) "commandId", NULL
25560 };
25561
25562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25563 if (obj0) {
25564 ecode1 = SWIG_AsVal_int(obj0, &val1);
25565 if (!SWIG_IsOK(ecode1)) {
25566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25567 }
25568 arg1 = static_cast< int >(val1);
25569 }
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25586 bool result;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 PyObject *swig_obj[1] ;
25590
25591 if (!args) SWIG_fail;
25592 swig_obj[0] = args;
25593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25594 if (!SWIG_IsOK(res1)) {
25595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25596 }
25597 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25614 PyObject *resultobj = 0;
25615 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25616 bool result;
25617 void *argp1 = 0 ;
25618 int res1 = 0 ;
25619 PyObject *swig_obj[1] ;
25620
25621 if (!args) SWIG_fail;
25622 swig_obj[0] = args;
25623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25624 if (!SWIG_IsOK(res1)) {
25625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25626 }
25627 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25644 PyObject *resultobj = 0;
25645 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25646 bool result;
25647 void *argp1 = 0 ;
25648 int res1 = 0 ;
25649 PyObject *swig_obj[1] ;
25650
25651 if (!args) SWIG_fail;
25652 swig_obj[0] = args;
25653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25654 if (!SWIG_IsOK(res1)) {
25655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25656 }
25657 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 {
25665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25666 }
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25676 wxString result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25686 }
25687 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 #if wxUSE_UNICODE
25696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25697 #else
25698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25699 #endif
25700 }
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708 PyObject *resultobj = 0;
25709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25710 bool result;
25711 void *argp1 = 0 ;
25712 int res1 = 0 ;
25713 PyObject *swig_obj[1] ;
25714
25715 if (!args) SWIG_fail;
25716 swig_obj[0] = args;
25717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25718 if (!SWIG_IsOK(res1)) {
25719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25720 }
25721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 {
25729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25738 PyObject *resultobj = 0;
25739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25740 bool result;
25741 void *argp1 = 0 ;
25742 int res1 = 0 ;
25743 PyObject *swig_obj[1] ;
25744
25745 if (!args) SWIG_fail;
25746 swig_obj[0] = args;
25747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25750 }
25751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25755 wxPyEndAllowThreads(__tstate);
25756 if (PyErr_Occurred()) SWIG_fail;
25757 }
25758 {
25759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25760 }
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25768 PyObject *resultobj = 0;
25769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25770 bool result;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 PyObject *swig_obj[1] ;
25774
25775 if (!args) SWIG_fail;
25776 swig_obj[0] = args;
25777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25780 }
25781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25782 {
25783 PyThreadState* __tstate = wxPyBeginAllowThreads();
25784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25785 wxPyEndAllowThreads(__tstate);
25786 if (PyErr_Occurred()) SWIG_fail;
25787 }
25788 {
25789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25790 }
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *resultobj = 0;
25799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25800 bool result;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 PyObject *swig_obj[1] ;
25804
25805 if (!args) SWIG_fail;
25806 swig_obj[0] = args;
25807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25810 }
25811 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25830 bool arg2 ;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 bool val2 ;
25834 int ecode2 = 0 ;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "check", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25845 }
25846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25848 if (!SWIG_IsOK(ecode2)) {
25849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25850 }
25851 arg2 = static_cast< bool >(val2);
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 (arg1)->Check(arg2);
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 resultobj = SWIG_Py_Void();
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj = 0;
25867 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25868 bool arg2 ;
25869 void *argp1 = 0 ;
25870 int res1 = 0 ;
25871 bool val2 ;
25872 int ecode2 = 0 ;
25873 PyObject * obj0 = 0 ;
25874 PyObject * obj1 = 0 ;
25875 char * kwnames[] = {
25876 (char *) "self",(char *) "enable", NULL
25877 };
25878
25879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25881 if (!SWIG_IsOK(res1)) {
25882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25883 }
25884 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25886 if (!SWIG_IsOK(ecode2)) {
25887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25888 }
25889 arg2 = static_cast< bool >(val2);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 (arg1)->Enable(arg2);
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_Py_Void();
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj = 0;
25905 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25906 bool arg2 ;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 bool val2 ;
25910 int ecode2 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char * kwnames[] = {
25914 (char *) "self",(char *) "show", NULL
25915 };
25916
25917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25919 if (!SWIG_IsOK(res1)) {
25920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25921 }
25922 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25924 if (!SWIG_IsOK(ecode2)) {
25925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25926 }
25927 arg2 = static_cast< bool >(val2);
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 (arg1)->Show(arg2);
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 resultobj = SWIG_Py_Void();
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj = 0;
25943 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25944 wxString *arg2 = 0 ;
25945 void *argp1 = 0 ;
25946 int res1 = 0 ;
25947 bool temp2 = false ;
25948 PyObject * obj0 = 0 ;
25949 PyObject * obj1 = 0 ;
25950 char * kwnames[] = {
25951 (char *) "self",(char *) "text", NULL
25952 };
25953
25954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25956 if (!SWIG_IsOK(res1)) {
25957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25958 }
25959 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25960 {
25961 arg2 = wxString_in_helper(obj1);
25962 if (arg2 == NULL) SWIG_fail;
25963 temp2 = true;
25964 }
25965 {
25966 PyThreadState* __tstate = wxPyBeginAllowThreads();
25967 (arg1)->SetText((wxString const &)*arg2);
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 resultobj = SWIG_Py_Void();
25972 {
25973 if (temp2)
25974 delete arg2;
25975 }
25976 return resultobj;
25977 fail:
25978 {
25979 if (temp2)
25980 delete arg2;
25981 }
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 long arg1 ;
25989 long val1 ;
25990 int ecode1 = 0 ;
25991 PyObject * obj0 = 0 ;
25992 char * kwnames[] = {
25993 (char *) "updateInterval", NULL
25994 };
25995
25996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25997 ecode1 = SWIG_AsVal_long(obj0, &val1);
25998 if (!SWIG_IsOK(ecode1)) {
25999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26000 }
26001 arg1 = static_cast< long >(val1);
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 wxUpdateUIEvent::SetUpdateInterval(arg1);
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 resultobj = SWIG_Py_Void();
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26016 PyObject *resultobj = 0;
26017 long result;
26018
26019 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 resultobj = SWIG_From_long(static_cast< long >(result));
26027 return resultobj;
26028 fail:
26029 return NULL;
26030 }
26031
26032
26033 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26034 PyObject *resultobj = 0;
26035 wxWindow *arg1 = (wxWindow *) 0 ;
26036 bool result;
26037 void *argp1 = 0 ;
26038 int res1 = 0 ;
26039 PyObject * obj0 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "win", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26048 }
26049 arg1 = reinterpret_cast< wxWindow * >(argp1);
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 {
26057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26058 }
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26066 PyObject *resultobj = 0;
26067
26068 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 wxUpdateUIEvent::ResetUpdateTime();
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 resultobj = SWIG_Py_Void();
26076 return resultobj;
26077 fail:
26078 return NULL;
26079 }
26080
26081
26082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26083 PyObject *resultobj = 0;
26084 wxUpdateUIMode arg1 ;
26085 int val1 ;
26086 int ecode1 = 0 ;
26087 PyObject * obj0 = 0 ;
26088 char * kwnames[] = {
26089 (char *) "mode", NULL
26090 };
26091
26092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26093 ecode1 = SWIG_AsVal_int(obj0, &val1);
26094 if (!SWIG_IsOK(ecode1)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26096 }
26097 arg1 = static_cast< wxUpdateUIMode >(val1);
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 wxUpdateUIEvent::SetMode(arg1);
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 resultobj = SWIG_Py_Void();
26105 return resultobj;
26106 fail:
26107 return NULL;
26108 }
26109
26110
26111 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26112 PyObject *resultobj = 0;
26113 wxUpdateUIMode result;
26114
26115 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_From_int(static_cast< int >(result));
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *obj;
26131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26132 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26133 return SWIG_Py_Void();
26134 }
26135
26136 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26137 return SWIG_Python_InitShadowInstance(args);
26138 }
26139
26140 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26141 PyObject *resultobj = 0;
26142 wxSysColourChangedEvent *result = 0 ;
26143
26144 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26159 PyObject *obj;
26160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26161 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26162 return SWIG_Py_Void();
26163 }
26164
26165 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 return SWIG_Python_InitShadowInstance(args);
26167 }
26168
26169 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj = 0;
26171 int arg1 = (int) 0 ;
26172 wxWindow *arg2 = (wxWindow *) NULL ;
26173 wxMouseCaptureChangedEvent *result = 0 ;
26174 int val1 ;
26175 int ecode1 = 0 ;
26176 void *argp2 = 0 ;
26177 int res2 = 0 ;
26178 PyObject * obj0 = 0 ;
26179 PyObject * obj1 = 0 ;
26180 char * kwnames[] = {
26181 (char *) "winid",(char *) "gainedCapture", NULL
26182 };
26183
26184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26185 if (obj0) {
26186 ecode1 = SWIG_AsVal_int(obj0, &val1);
26187 if (!SWIG_IsOK(ecode1)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26189 }
26190 arg1 = static_cast< int >(val1);
26191 }
26192 if (obj1) {
26193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26194 if (!SWIG_IsOK(res2)) {
26195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26196 }
26197 arg2 = reinterpret_cast< wxWindow * >(argp2);
26198 }
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26213 PyObject *resultobj = 0;
26214 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26215 wxWindow *result = 0 ;
26216 void *argp1 = 0 ;
26217 int res1 = 0 ;
26218 PyObject *swig_obj[1] ;
26219
26220 if (!args) SWIG_fail;
26221 swig_obj[0] = args;
26222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26225 }
26226 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 resultobj = wxPyMake_wxObject(result, (bool)0);
26235 }
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *obj;
26244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26245 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26246 return SWIG_Py_Void();
26247 }
26248
26249 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26250 return SWIG_Python_InitShadowInstance(args);
26251 }
26252
26253 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj = 0;
26255 int arg1 = (int) 0 ;
26256 wxMouseCaptureLostEvent *result = 0 ;
26257 int val1 ;
26258 int ecode1 = 0 ;
26259 PyObject * obj0 = 0 ;
26260 char * kwnames[] = {
26261 (char *) "winid", NULL
26262 };
26263
26264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26265 if (obj0) {
26266 ecode1 = SWIG_AsVal_int(obj0, &val1);
26267 if (!SWIG_IsOK(ecode1)) {
26268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26269 }
26270 arg1 = static_cast< int >(val1);
26271 }
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 PyObject *obj;
26287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26288 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26289 return SWIG_Py_Void();
26290 }
26291
26292 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293 return SWIG_Python_InitShadowInstance(args);
26294 }
26295
26296 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *resultobj = 0;
26298 wxDisplayChangedEvent *result = 0 ;
26299
26300 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26315 PyObject *obj;
26316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26317 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26318 return SWIG_Py_Void();
26319 }
26320
26321 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26322 return SWIG_Python_InitShadowInstance(args);
26323 }
26324
26325 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = 0;
26327 int arg1 = (int) 0 ;
26328 wxPaletteChangedEvent *result = 0 ;
26329 int val1 ;
26330 int ecode1 = 0 ;
26331 PyObject * obj0 = 0 ;
26332 char * kwnames[] = {
26333 (char *) "id", NULL
26334 };
26335
26336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26337 if (obj0) {
26338 ecode1 = SWIG_AsVal_int(obj0, &val1);
26339 if (!SWIG_IsOK(ecode1)) {
26340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26341 }
26342 arg1 = static_cast< int >(val1);
26343 }
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj = 0;
26359 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26360 wxWindow *arg2 = (wxWindow *) 0 ;
26361 void *argp1 = 0 ;
26362 int res1 = 0 ;
26363 void *argp2 = 0 ;
26364 int res2 = 0 ;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367 char * kwnames[] = {
26368 (char *) "self",(char *) "win", NULL
26369 };
26370
26371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26375 }
26376 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26378 if (!SWIG_IsOK(res2)) {
26379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26380 }
26381 arg2 = reinterpret_cast< wxWindow * >(argp2);
26382 {
26383 PyThreadState* __tstate = wxPyBeginAllowThreads();
26384 (arg1)->SetChangedWindow(arg2);
26385 wxPyEndAllowThreads(__tstate);
26386 if (PyErr_Occurred()) SWIG_fail;
26387 }
26388 resultobj = SWIG_Py_Void();
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26396 PyObject *resultobj = 0;
26397 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26398 wxWindow *result = 0 ;
26399 void *argp1 = 0 ;
26400 int res1 = 0 ;
26401 PyObject *swig_obj[1] ;
26402
26403 if (!args) SWIG_fail;
26404 swig_obj[0] = args;
26405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26406 if (!SWIG_IsOK(res1)) {
26407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26408 }
26409 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxWindow *)(arg1)->GetChangedWindow();
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = wxPyMake_wxObject(result, (bool)0);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26426 PyObject *obj;
26427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26428 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26429 return SWIG_Py_Void();
26430 }
26431
26432 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26433 return SWIG_Python_InitShadowInstance(args);
26434 }
26435
26436 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj = 0;
26438 int arg1 = (int) 0 ;
26439 wxQueryNewPaletteEvent *result = 0 ;
26440 int val1 ;
26441 int ecode1 = 0 ;
26442 PyObject * obj0 = 0 ;
26443 char * kwnames[] = {
26444 (char *) "winid", NULL
26445 };
26446
26447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26448 if (obj0) {
26449 ecode1 = SWIG_AsVal_int(obj0, &val1);
26450 if (!SWIG_IsOK(ecode1)) {
26451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26452 }
26453 arg1 = static_cast< int >(val1);
26454 }
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26458 wxPyEndAllowThreads(__tstate);
26459 if (PyErr_Occurred()) SWIG_fail;
26460 }
26461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj = 0;
26470 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26471 bool arg2 ;
26472 void *argp1 = 0 ;
26473 int res1 = 0 ;
26474 bool val2 ;
26475 int ecode2 = 0 ;
26476 PyObject * obj0 = 0 ;
26477 PyObject * obj1 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "self",(char *) "realized", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26484 if (!SWIG_IsOK(res1)) {
26485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26486 }
26487 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26488 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26489 if (!SWIG_IsOK(ecode2)) {
26490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26491 }
26492 arg2 = static_cast< bool >(val2);
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 (arg1)->SetPaletteRealized(arg2);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_Py_Void();
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *resultobj = 0;
26508 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26509 bool result;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 PyObject *swig_obj[1] ;
26513
26514 if (!args) SWIG_fail;
26515 swig_obj[0] = args;
26516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26519 }
26520 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 {
26528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26529 }
26530 return resultobj;
26531 fail:
26532 return NULL;
26533 }
26534
26535
26536 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26537 PyObject *obj;
26538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26539 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26540 return SWIG_Py_Void();
26541 }
26542
26543 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26544 return SWIG_Python_InitShadowInstance(args);
26545 }
26546
26547 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxNavigationKeyEvent *result = 0 ;
26550
26551 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *resultobj = 0;
26567 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26568 bool result;
26569 void *argp1 = 0 ;
26570 int res1 = 0 ;
26571 PyObject *swig_obj[1] ;
26572
26573 if (!args) SWIG_fail;
26574 swig_obj[0] = args;
26575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26576 if (!SWIG_IsOK(res1)) {
26577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26578 }
26579 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 {
26587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26588 }
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26598 bool arg2 ;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool val2 ;
26602 int ecode2 = 0 ;
26603 PyObject * obj0 = 0 ;
26604 PyObject * obj1 = 0 ;
26605 char * kwnames[] = {
26606 (char *) "self",(char *) "forward", NULL
26607 };
26608
26609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26611 if (!SWIG_IsOK(res1)) {
26612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26613 }
26614 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26616 if (!SWIG_IsOK(ecode2)) {
26617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26618 }
26619 arg2 = static_cast< bool >(val2);
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 (arg1)->SetDirection(arg2);
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_Py_Void();
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26634 PyObject *resultobj = 0;
26635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26636 bool result;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 PyObject *swig_obj[1] ;
26640
26641 if (!args) SWIG_fail;
26642 swig_obj[0] = args;
26643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26644 if (!SWIG_IsOK(res1)) {
26645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26646 }
26647 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 {
26655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26656 }
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26666 bool arg2 ;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 bool val2 ;
26670 int ecode2 = 0 ;
26671 PyObject * obj0 = 0 ;
26672 PyObject * obj1 = 0 ;
26673 char * kwnames[] = {
26674 (char *) "self",(char *) "ischange", NULL
26675 };
26676
26677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26679 if (!SWIG_IsOK(res1)) {
26680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26681 }
26682 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26686 }
26687 arg2 = static_cast< bool >(val2);
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 (arg1)->SetWindowChange(arg2);
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 resultobj = SWIG_Py_Void();
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 PyObject *resultobj = 0;
26703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26704 bool result;
26705 void *argp1 = 0 ;
26706 int res1 = 0 ;
26707 PyObject *swig_obj[1] ;
26708
26709 if (!args) SWIG_fail;
26710 swig_obj[0] = args;
26711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26734 bool arg2 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 bool val2 ;
26738 int ecode2 = 0 ;
26739 PyObject * obj0 = 0 ;
26740 PyObject * obj1 = 0 ;
26741 char * kwnames[] = {
26742 (char *) "self",(char *) "bIs", NULL
26743 };
26744
26745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26747 if (!SWIG_IsOK(res1)) {
26748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26749 }
26750 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26751 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26752 if (!SWIG_IsOK(ecode2)) {
26753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26754 }
26755 arg2 = static_cast< bool >(val2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetFromTab(arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26772 long arg2 ;
26773 void *argp1 = 0 ;
26774 int res1 = 0 ;
26775 long val2 ;
26776 int ecode2 = 0 ;
26777 PyObject * obj0 = 0 ;
26778 PyObject * obj1 = 0 ;
26779 char * kwnames[] = {
26780 (char *) "self",(char *) "flags", NULL
26781 };
26782
26783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26785 if (!SWIG_IsOK(res1)) {
26786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26787 }
26788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26789 ecode2 = SWIG_AsVal_long(obj1, &val2);
26790 if (!SWIG_IsOK(ecode2)) {
26791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26792 }
26793 arg2 = static_cast< long >(val2);
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 (arg1)->SetFlags(arg2);
26797 wxPyEndAllowThreads(__tstate);
26798 if (PyErr_Occurred()) SWIG_fail;
26799 }
26800 resultobj = SWIG_Py_Void();
26801 return resultobj;
26802 fail:
26803 return NULL;
26804 }
26805
26806
26807 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26808 PyObject *resultobj = 0;
26809 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26810 wxWindow *result = 0 ;
26811 void *argp1 = 0 ;
26812 int res1 = 0 ;
26813 PyObject *swig_obj[1] ;
26814
26815 if (!args) SWIG_fail;
26816 swig_obj[0] = args;
26817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26818 if (!SWIG_IsOK(res1)) {
26819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26820 }
26821 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26825 wxPyEndAllowThreads(__tstate);
26826 if (PyErr_Occurred()) SWIG_fail;
26827 }
26828 {
26829 resultobj = wxPyMake_wxObject(result, (bool)0);
26830 }
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26838 PyObject *resultobj = 0;
26839 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26840 wxWindow *arg2 = (wxWindow *) 0 ;
26841 void *argp1 = 0 ;
26842 int res1 = 0 ;
26843 void *argp2 = 0 ;
26844 int res2 = 0 ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "win", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26855 }
26856 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26858 if (!SWIG_IsOK(res2)) {
26859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26860 }
26861 arg2 = reinterpret_cast< wxWindow * >(argp2);
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 (arg1)->SetCurrentFocus(arg2);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_Py_Void();
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26876 PyObject *obj;
26877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26878 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26879 return SWIG_Py_Void();
26880 }
26881
26882 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 return SWIG_Python_InitShadowInstance(args);
26884 }
26885
26886 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26887 PyObject *resultobj = 0;
26888 wxWindow *arg1 = (wxWindow *) NULL ;
26889 wxWindowCreateEvent *result = 0 ;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 PyObject * obj0 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "win", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26898 if (obj0) {
26899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26900 if (!SWIG_IsOK(res1)) {
26901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26902 }
26903 arg1 = reinterpret_cast< wxWindow * >(argp1);
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26919 PyObject *resultobj = 0;
26920 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26921 wxWindow *result = 0 ;
26922 void *argp1 = 0 ;
26923 int res1 = 0 ;
26924 PyObject *swig_obj[1] ;
26925
26926 if (!args) SWIG_fail;
26927 swig_obj[0] = args;
26928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26929 if (!SWIG_IsOK(res1)) {
26930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26931 }
26932 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 resultobj = wxPyMake_wxObject(result, (bool)0);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26949 PyObject *obj;
26950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26951 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26952 return SWIG_Py_Void();
26953 }
26954
26955 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 return SWIG_Python_InitShadowInstance(args);
26957 }
26958
26959 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj = 0;
26961 wxWindow *arg1 = (wxWindow *) NULL ;
26962 wxWindowDestroyEvent *result = 0 ;
26963 void *argp1 = 0 ;
26964 int res1 = 0 ;
26965 PyObject * obj0 = 0 ;
26966 char * kwnames[] = {
26967 (char *) "win", NULL
26968 };
26969
26970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26971 if (obj0) {
26972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26975 }
26976 arg1 = reinterpret_cast< wxWindow * >(argp1);
26977 }
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26981 wxPyEndAllowThreads(__tstate);
26982 if (PyErr_Occurred()) SWIG_fail;
26983 }
26984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26985 return resultobj;
26986 fail:
26987 return NULL;
26988 }
26989
26990
26991 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26992 PyObject *resultobj = 0;
26993 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26994 wxWindow *result = 0 ;
26995 void *argp1 = 0 ;
26996 int res1 = 0 ;
26997 PyObject *swig_obj[1] ;
26998
26999 if (!args) SWIG_fail;
27000 swig_obj[0] = args;
27001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27002 if (!SWIG_IsOK(res1)) {
27003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27004 }
27005 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 {
27013 resultobj = wxPyMake_wxObject(result, (bool)0);
27014 }
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27022 PyObject *obj;
27023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27024 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27025 return SWIG_Py_Void();
27026 }
27027
27028 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 return SWIG_Python_InitShadowInstance(args);
27030 }
27031
27032 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = 0;
27034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27035 int arg2 = (int) 0 ;
27036 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27037 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27038 wxContextMenuEvent *result = 0 ;
27039 int val1 ;
27040 int ecode1 = 0 ;
27041 int val2 ;
27042 int ecode2 = 0 ;
27043 wxPoint temp3 ;
27044 PyObject * obj0 = 0 ;
27045 PyObject * obj1 = 0 ;
27046 PyObject * obj2 = 0 ;
27047 char * kwnames[] = {
27048 (char *) "type",(char *) "winid",(char *) "pt", NULL
27049 };
27050
27051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27052 if (obj0) {
27053 ecode1 = SWIG_AsVal_int(obj0, &val1);
27054 if (!SWIG_IsOK(ecode1)) {
27055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27056 }
27057 arg1 = static_cast< wxEventType >(val1);
27058 }
27059 if (obj1) {
27060 ecode2 = SWIG_AsVal_int(obj1, &val2);
27061 if (!SWIG_IsOK(ecode2)) {
27062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27063 }
27064 arg2 = static_cast< int >(val2);
27065 }
27066 if (obj2) {
27067 {
27068 arg3 = &temp3;
27069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27070 }
27071 }
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27086 PyObject *resultobj = 0;
27087 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27088 wxPoint *result = 0 ;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 PyObject *swig_obj[1] ;
27092
27093 if (!args) SWIG_fail;
27094 swig_obj[0] = args;
27095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27098 }
27099 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27100 {
27101 PyThreadState* __tstate = wxPyBeginAllowThreads();
27102 {
27103 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27104 result = (wxPoint *) &_result_ref;
27105 }
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = 0;
27118 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27119 wxPoint *arg2 = 0 ;
27120 void *argp1 = 0 ;
27121 int res1 = 0 ;
27122 wxPoint temp2 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char * kwnames[] = {
27126 (char *) "self",(char *) "pos", NULL
27127 };
27128
27129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27133 }
27134 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27135 {
27136 arg2 = &temp2;
27137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27138 }
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 (arg1)->SetPosition((wxPoint const &)*arg2);
27142 wxPyEndAllowThreads(__tstate);
27143 if (PyErr_Occurred()) SWIG_fail;
27144 }
27145 resultobj = SWIG_Py_Void();
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27153 PyObject *obj;
27154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27155 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27156 return SWIG_Py_Void();
27157 }
27158
27159 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 return SWIG_Python_InitShadowInstance(args);
27161 }
27162
27163 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *resultobj = 0;
27165 wxIdleEvent *result = 0 ;
27166
27167 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (wxIdleEvent *)new wxIdleEvent();
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27182 PyObject *resultobj = 0;
27183 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27184 bool arg2 = (bool) true ;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 bool val2 ;
27188 int ecode2 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "self",(char *) "needMore", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27199 }
27200 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27201 if (obj1) {
27202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27203 if (!SWIG_IsOK(ecode2)) {
27204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27205 }
27206 arg2 = static_cast< bool >(val2);
27207 }
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 (arg1)->RequestMore(arg2);
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 resultobj = SWIG_Py_Void();
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27222 PyObject *resultobj = 0;
27223 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27224 bool result;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 PyObject *swig_obj[1] ;
27228
27229 if (!args) SWIG_fail;
27230 swig_obj[0] = args;
27231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27232 if (!SWIG_IsOK(res1)) {
27233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27234 }
27235 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 {
27243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27244 }
27245 return resultobj;
27246 fail:
27247 return NULL;
27248 }
27249
27250
27251 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27252 PyObject *resultobj = 0;
27253 wxIdleMode arg1 ;
27254 int val1 ;
27255 int ecode1 = 0 ;
27256 PyObject * obj0 = 0 ;
27257 char * kwnames[] = {
27258 (char *) "mode", NULL
27259 };
27260
27261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27262 ecode1 = SWIG_AsVal_int(obj0, &val1);
27263 if (!SWIG_IsOK(ecode1)) {
27264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27265 }
27266 arg1 = static_cast< wxIdleMode >(val1);
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 wxIdleEvent::SetMode(arg1);
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_Py_Void();
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxIdleMode result;
27283
27284 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = (wxIdleMode)wxIdleEvent::GetMode();
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 resultobj = SWIG_From_int(static_cast< int >(result));
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj = 0;
27300 wxWindow *arg1 = (wxWindow *) 0 ;
27301 bool result;
27302 void *argp1 = 0 ;
27303 int res1 = 0 ;
27304 PyObject * obj0 = 0 ;
27305 char * kwnames[] = {
27306 (char *) "win", NULL
27307 };
27308
27309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27311 if (!SWIG_IsOK(res1)) {
27312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27313 }
27314 arg1 = reinterpret_cast< wxWindow * >(argp1);
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 result = (bool)wxIdleEvent::CanSend(arg1);
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 {
27322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27323 }
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27331 PyObject *obj;
27332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27333 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27334 return SWIG_Py_Void();
27335 }
27336
27337 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27338 return SWIG_Python_InitShadowInstance(args);
27339 }
27340
27341 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj = 0;
27343 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27344 int arg2 = (int) 0 ;
27345 wxClipboardTextEvent *result = 0 ;
27346 int val1 ;
27347 int ecode1 = 0 ;
27348 int val2 ;
27349 int ecode2 = 0 ;
27350 PyObject * obj0 = 0 ;
27351 PyObject * obj1 = 0 ;
27352 char * kwnames[] = {
27353 (char *) "type",(char *) "winid", NULL
27354 };
27355
27356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27357 if (obj0) {
27358 ecode1 = SWIG_AsVal_int(obj0, &val1);
27359 if (!SWIG_IsOK(ecode1)) {
27360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27361 }
27362 arg1 = static_cast< wxEventType >(val1);
27363 }
27364 if (obj1) {
27365 ecode2 = SWIG_AsVal_int(obj1, &val2);
27366 if (!SWIG_IsOK(ecode2)) {
27367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27368 }
27369 arg2 = static_cast< int >(val2);
27370 }
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *obj;
27386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27387 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27388 return SWIG_Py_Void();
27389 }
27390
27391 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27392 return SWIG_Python_InitShadowInstance(args);
27393 }
27394
27395 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27396 PyObject *resultobj = 0;
27397 int arg1 = (int) 0 ;
27398 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27399 wxPyEvent *result = 0 ;
27400 int val1 ;
27401 int ecode1 = 0 ;
27402 int val2 ;
27403 int ecode2 = 0 ;
27404 PyObject * obj0 = 0 ;
27405 PyObject * obj1 = 0 ;
27406 char * kwnames[] = {
27407 (char *) "winid",(char *) "eventType", NULL
27408 };
27409
27410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27411 if (obj0) {
27412 ecode1 = SWIG_AsVal_int(obj0, &val1);
27413 if (!SWIG_IsOK(ecode1)) {
27414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27415 }
27416 arg1 = static_cast< int >(val1);
27417 }
27418 if (obj1) {
27419 ecode2 = SWIG_AsVal_int(obj1, &val2);
27420 if (!SWIG_IsOK(ecode2)) {
27421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27422 }
27423 arg2 = static_cast< wxEventType >(val2);
27424 }
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27441 void *argp1 = 0 ;
27442 int res1 = 0 ;
27443 PyObject *swig_obj[1] ;
27444
27445 if (!args) SWIG_fail;
27446 swig_obj[0] = args;
27447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 delete arg1;
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 resultobj = SWIG_Py_Void();
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27467 PyObject *resultobj = 0;
27468 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27469 PyObject *arg2 = (PyObject *) 0 ;
27470 void *argp1 = 0 ;
27471 int res1 = 0 ;
27472 PyObject * obj0 = 0 ;
27473 PyObject * obj1 = 0 ;
27474 char * kwnames[] = {
27475 (char *) "self",(char *) "self", NULL
27476 };
27477
27478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27480 if (!SWIG_IsOK(res1)) {
27481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27482 }
27483 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27484 arg2 = obj1;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 (arg1)->SetSelf(arg2);
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_Py_Void();
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27499 PyObject *resultobj = 0;
27500 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27501 PyObject *result = 0 ;
27502 void *argp1 = 0 ;
27503 int res1 = 0 ;
27504 PyObject *swig_obj[1] ;
27505
27506 if (!args) SWIG_fail;
27507 swig_obj[0] = args;
27508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27511 }
27512 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = (PyObject *)(arg1)->GetSelf();
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = result;
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *obj;
27528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27529 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27530 return SWIG_Py_Void();
27531 }
27532
27533 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27534 return SWIG_Python_InitShadowInstance(args);
27535 }
27536
27537 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = 0;
27539 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27540 int arg2 = (int) 0 ;
27541 wxPyCommandEvent *result = 0 ;
27542 int val1 ;
27543 int ecode1 = 0 ;
27544 int val2 ;
27545 int ecode2 = 0 ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 char * kwnames[] = {
27549 (char *) "eventType",(char *) "id", NULL
27550 };
27551
27552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27553 if (obj0) {
27554 ecode1 = SWIG_AsVal_int(obj0, &val1);
27555 if (!SWIG_IsOK(ecode1)) {
27556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27557 }
27558 arg1 = static_cast< wxEventType >(val1);
27559 }
27560 if (obj1) {
27561 ecode2 = SWIG_AsVal_int(obj1, &val2);
27562 if (!SWIG_IsOK(ecode2)) {
27563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27564 }
27565 arg2 = static_cast< int >(val2);
27566 }
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27581 PyObject *resultobj = 0;
27582 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27583 void *argp1 = 0 ;
27584 int res1 = 0 ;
27585 PyObject *swig_obj[1] ;
27586
27587 if (!args) SWIG_fail;
27588 swig_obj[0] = args;
27589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27590 if (!SWIG_IsOK(res1)) {
27591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27592 }
27593 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 delete arg1;
27597
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 resultobj = SWIG_Py_Void();
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj = 0;
27610 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27611 PyObject *arg2 = (PyObject *) 0 ;
27612 void *argp1 = 0 ;
27613 int res1 = 0 ;
27614 PyObject * obj0 = 0 ;
27615 PyObject * obj1 = 0 ;
27616 char * kwnames[] = {
27617 (char *) "self",(char *) "self", NULL
27618 };
27619
27620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27624 }
27625 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27626 arg2 = obj1;
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 (arg1)->SetSelf(arg2);
27630 wxPyEndAllowThreads(__tstate);
27631 if (PyErr_Occurred()) SWIG_fail;
27632 }
27633 resultobj = SWIG_Py_Void();
27634 return resultobj;
27635 fail:
27636 return NULL;
27637 }
27638
27639
27640 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27641 PyObject *resultobj = 0;
27642 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27643 PyObject *result = 0 ;
27644 void *argp1 = 0 ;
27645 int res1 = 0 ;
27646 PyObject *swig_obj[1] ;
27647
27648 if (!args) SWIG_fail;
27649 swig_obj[0] = args;
27650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27651 if (!SWIG_IsOK(res1)) {
27652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27653 }
27654 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (PyObject *)(arg1)->GetSelf();
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 resultobj = result;
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27669 PyObject *obj;
27670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27672 return SWIG_Py_Void();
27673 }
27674
27675 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27676 return SWIG_Python_InitShadowInstance(args);
27677 }
27678
27679 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj = 0;
27681 wxWindow *arg1 = (wxWindow *) 0 ;
27682 wxDateTime *arg2 = 0 ;
27683 wxEventType arg3 ;
27684 wxDateEvent *result = 0 ;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 void *argp2 = 0 ;
27688 int res2 = 0 ;
27689 int val3 ;
27690 int ecode3 = 0 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 PyObject * obj2 = 0 ;
27694 char * kwnames[] = {
27695 (char *) "win",(char *) "dt",(char *) "type", NULL
27696 };
27697
27698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27702 }
27703 arg1 = reinterpret_cast< wxWindow * >(argp1);
27704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27705 if (!SWIG_IsOK(res2)) {
27706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27707 }
27708 if (!argp2) {
27709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27710 }
27711 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27712 ecode3 = SWIG_AsVal_int(obj2, &val3);
27713 if (!SWIG_IsOK(ecode3)) {
27714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27715 }
27716 arg3 = static_cast< wxEventType >(val3);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27733 wxDateTime *result = 0 ;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 PyObject *swig_obj[1] ;
27737
27738 if (!args) SWIG_fail;
27739 swig_obj[0] = args;
27740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27743 }
27744 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 {
27748 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27749 result = (wxDateTime *) &_result_ref;
27750 }
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj = 0;
27763 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27764 wxDateTime *arg2 = 0 ;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 void *argp2 = 0 ;
27768 int res2 = 0 ;
27769 PyObject * obj0 = 0 ;
27770 PyObject * obj1 = 0 ;
27771 char * kwnames[] = {
27772 (char *) "self",(char *) "date", NULL
27773 };
27774
27775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27779 }
27780 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27781 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27782 if (!SWIG_IsOK(res2)) {
27783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27784 }
27785 if (!argp2) {
27786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27787 }
27788 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 (arg1)->SetDate((wxDateTime const &)*arg2);
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 resultobj = SWIG_Py_Void();
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *obj;
27804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27805 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27806 return SWIG_Py_Void();
27807 }
27808
27809 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 return SWIG_Python_InitShadowInstance(args);
27811 }
27812
27813 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27814 PyObject *resultobj = 0;
27815 wxPyApp *result = 0 ;
27816
27817 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27818 {
27819 PyThreadState* __tstate = wxPyBeginAllowThreads();
27820 result = (wxPyApp *)new_wxPyApp();
27821 wxPyEndAllowThreads(__tstate);
27822 if (PyErr_Occurred()) SWIG_fail;
27823 }
27824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27832 PyObject *resultobj = 0;
27833 wxPyApp *arg1 = (wxPyApp *) 0 ;
27834 void *argp1 = 0 ;
27835 int res1 = 0 ;
27836 PyObject *swig_obj[1] ;
27837
27838 if (!args) SWIG_fail;
27839 swig_obj[0] = args;
27840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27841 if (!SWIG_IsOK(res1)) {
27842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27843 }
27844 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 delete arg1;
27848
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_Py_Void();
27853 return resultobj;
27854 fail:
27855 return NULL;
27856 }
27857
27858
27859 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27860 PyObject *resultobj = 0;
27861 wxPyApp *arg1 = (wxPyApp *) 0 ;
27862 PyObject *arg2 = (PyObject *) 0 ;
27863 PyObject *arg3 = (PyObject *) 0 ;
27864 bool arg4 ;
27865 void *argp1 = 0 ;
27866 int res1 = 0 ;
27867 bool val4 ;
27868 int ecode4 = 0 ;
27869 PyObject * obj0 = 0 ;
27870 PyObject * obj1 = 0 ;
27871 PyObject * obj2 = 0 ;
27872 PyObject * obj3 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27881 }
27882 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27883 arg2 = obj1;
27884 arg3 = obj2;
27885 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27886 if (!SWIG_IsOK(ecode4)) {
27887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27888 }
27889 arg4 = static_cast< bool >(val4);
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = SWIG_Py_Void();
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27904 PyObject *resultobj = 0;
27905 wxPyApp *arg1 = (wxPyApp *) 0 ;
27906 wxString result;
27907 void *argp1 = 0 ;
27908 int res1 = 0 ;
27909 PyObject *swig_obj[1] ;
27910
27911 if (!args) SWIG_fail;
27912 swig_obj[0] = args;
27913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27914 if (!SWIG_IsOK(res1)) {
27915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27916 }
27917 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27918 {
27919 PyThreadState* __tstate = wxPyBeginAllowThreads();
27920 result = ((wxPyApp const *)arg1)->GetAppName();
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 #if wxUSE_UNICODE
27926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27927 #else
27928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27929 #endif
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj = 0;
27939 wxPyApp *arg1 = (wxPyApp *) 0 ;
27940 wxString *arg2 = 0 ;
27941 void *argp1 = 0 ;
27942 int res1 = 0 ;
27943 bool temp2 = false ;
27944 PyObject * obj0 = 0 ;
27945 PyObject * obj1 = 0 ;
27946 char * kwnames[] = {
27947 (char *) "self",(char *) "name", NULL
27948 };
27949
27950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27952 if (!SWIG_IsOK(res1)) {
27953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27954 }
27955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27956 {
27957 arg2 = wxString_in_helper(obj1);
27958 if (arg2 == NULL) SWIG_fail;
27959 temp2 = true;
27960 }
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 (arg1)->SetAppName((wxString const &)*arg2);
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 resultobj = SWIG_Py_Void();
27968 {
27969 if (temp2)
27970 delete arg2;
27971 }
27972 return resultobj;
27973 fail:
27974 {
27975 if (temp2)
27976 delete arg2;
27977 }
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27983 PyObject *resultobj = 0;
27984 wxPyApp *arg1 = (wxPyApp *) 0 ;
27985 wxString result;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 PyObject *swig_obj[1] ;
27989
27990 if (!args) SWIG_fail;
27991 swig_obj[0] = args;
27992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27993 if (!SWIG_IsOK(res1)) {
27994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27995 }
27996 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 result = ((wxPyApp const *)arg1)->GetClassName();
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 {
28004 #if wxUSE_UNICODE
28005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28006 #else
28007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28008 #endif
28009 }
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28017 PyObject *resultobj = 0;
28018 wxPyApp *arg1 = (wxPyApp *) 0 ;
28019 wxString *arg2 = 0 ;
28020 void *argp1 = 0 ;
28021 int res1 = 0 ;
28022 bool temp2 = false ;
28023 PyObject * obj0 = 0 ;
28024 PyObject * obj1 = 0 ;
28025 char * kwnames[] = {
28026 (char *) "self",(char *) "name", NULL
28027 };
28028
28029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28031 if (!SWIG_IsOK(res1)) {
28032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28033 }
28034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28035 {
28036 arg2 = wxString_in_helper(obj1);
28037 if (arg2 == NULL) SWIG_fail;
28038 temp2 = true;
28039 }
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 (arg1)->SetClassName((wxString const &)*arg2);
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 resultobj = SWIG_Py_Void();
28047 {
28048 if (temp2)
28049 delete arg2;
28050 }
28051 return resultobj;
28052 fail:
28053 {
28054 if (temp2)
28055 delete arg2;
28056 }
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28062 PyObject *resultobj = 0;
28063 wxPyApp *arg1 = (wxPyApp *) 0 ;
28064 wxString *result = 0 ;
28065 void *argp1 = 0 ;
28066 int res1 = 0 ;
28067 PyObject *swig_obj[1] ;
28068
28069 if (!args) SWIG_fail;
28070 swig_obj[0] = args;
28071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28072 if (!SWIG_IsOK(res1)) {
28073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28074 }
28075 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 {
28079 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28080 result = (wxString *) &_result_ref;
28081 }
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 {
28086 #if wxUSE_UNICODE
28087 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28088 #else
28089 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28090 #endif
28091 }
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj = 0;
28100 wxPyApp *arg1 = (wxPyApp *) 0 ;
28101 wxString *arg2 = 0 ;
28102 void *argp1 = 0 ;
28103 int res1 = 0 ;
28104 bool temp2 = false ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "name", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28115 }
28116 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28117 {
28118 arg2 = wxString_in_helper(obj1);
28119 if (arg2 == NULL) SWIG_fail;
28120 temp2 = true;
28121 }
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 (arg1)->SetVendorName((wxString const &)*arg2);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 {
28130 if (temp2)
28131 delete arg2;
28132 }
28133 return resultobj;
28134 fail:
28135 {
28136 if (temp2)
28137 delete arg2;
28138 }
28139 return NULL;
28140 }
28141
28142
28143 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28144 PyObject *resultobj = 0;
28145 wxPyApp *arg1 = (wxPyApp *) 0 ;
28146 wxAppTraits *result = 0 ;
28147 void *argp1 = 0 ;
28148 int res1 = 0 ;
28149 PyObject *swig_obj[1] ;
28150
28151 if (!args) SWIG_fail;
28152 swig_obj[0] = args;
28153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28154 if (!SWIG_IsOK(res1)) {
28155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28156 }
28157 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (wxAppTraits *)(arg1)->GetTraits();
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28165 return resultobj;
28166 fail:
28167 return NULL;
28168 }
28169
28170
28171 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28172 PyObject *resultobj = 0;
28173 wxPyApp *arg1 = (wxPyApp *) 0 ;
28174 void *argp1 = 0 ;
28175 int res1 = 0 ;
28176 PyObject *swig_obj[1] ;
28177
28178 if (!args) SWIG_fail;
28179 swig_obj[0] = args;
28180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28181 if (!SWIG_IsOK(res1)) {
28182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28183 }
28184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 (arg1)->ProcessPendingEvents();
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_Py_Void();
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj = 0;
28200 wxPyApp *arg1 = (wxPyApp *) 0 ;
28201 bool arg2 = (bool) false ;
28202 bool result;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 bool val2 ;
28206 int ecode2 = 0 ;
28207 PyObject * obj0 = 0 ;
28208 PyObject * obj1 = 0 ;
28209 char * kwnames[] = {
28210 (char *) "self",(char *) "onlyIfNeeded", NULL
28211 };
28212
28213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28215 if (!SWIG_IsOK(res1)) {
28216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28217 }
28218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28219 if (obj1) {
28220 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28221 if (!SWIG_IsOK(ecode2)) {
28222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28223 }
28224 arg2 = static_cast< bool >(val2);
28225 }
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)(arg1)->Yield(arg2);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 PyObject *resultobj = 0;
28243 wxPyApp *arg1 = (wxPyApp *) 0 ;
28244 void *argp1 = 0 ;
28245 int res1 = 0 ;
28246 PyObject *swig_obj[1] ;
28247
28248 if (!args) SWIG_fail;
28249 swig_obj[0] = args;
28250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28251 if (!SWIG_IsOK(res1)) {
28252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28253 }
28254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 (arg1)->WakeUpIdle();
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_Py_Void();
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28269 PyObject *resultobj = 0;
28270 bool result;
28271
28272 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (bool)wxPyApp::IsMainLoopRunning();
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 {
28280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28281 }
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28289 PyObject *resultobj = 0;
28290 wxPyApp *arg1 = (wxPyApp *) 0 ;
28291 int result;
28292 void *argp1 = 0 ;
28293 int res1 = 0 ;
28294 PyObject *swig_obj[1] ;
28295
28296 if (!args) SWIG_fail;
28297 swig_obj[0] = args;
28298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28301 }
28302 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (int)(arg1)->MainLoop();
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_From_int(static_cast< int >(result));
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28317 PyObject *resultobj = 0;
28318 wxPyApp *arg1 = (wxPyApp *) 0 ;
28319 void *argp1 = 0 ;
28320 int res1 = 0 ;
28321 PyObject *swig_obj[1] ;
28322
28323 if (!args) SWIG_fail;
28324 swig_obj[0] = args;
28325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28326 if (!SWIG_IsOK(res1)) {
28327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28328 }
28329 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 (arg1)->Exit();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_Py_Void();
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 wxPyApp *arg1 = (wxPyApp *) 0 ;
28346 wxLayoutDirection result;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 PyObject *swig_obj[1] ;
28350
28351 if (!args) SWIG_fail;
28352 swig_obj[0] = args;
28353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28354 if (!SWIG_IsOK(res1)) {
28355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28356 }
28357 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 resultobj = SWIG_From_int(static_cast< int >(result));
28365 return resultobj;
28366 fail:
28367 return NULL;
28368 }
28369
28370
28371 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 PyObject *resultobj = 0;
28373 wxPyApp *arg1 = (wxPyApp *) 0 ;
28374 void *argp1 = 0 ;
28375 int res1 = 0 ;
28376 PyObject *swig_obj[1] ;
28377
28378 if (!args) SWIG_fail;
28379 swig_obj[0] = args;
28380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28383 }
28384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 (arg1)->ExitMainLoop();
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_Py_Void();
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 PyObject *resultobj = 0;
28400 wxPyApp *arg1 = (wxPyApp *) 0 ;
28401 bool result;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 PyObject *swig_obj[1] ;
28405
28406 if (!args) SWIG_fail;
28407 swig_obj[0] = args;
28408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28409 if (!SWIG_IsOK(res1)) {
28410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28411 }
28412 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)(arg1)->Pending();
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 PyObject *resultobj = 0;
28430 wxPyApp *arg1 = (wxPyApp *) 0 ;
28431 bool result;
28432 void *argp1 = 0 ;
28433 int res1 = 0 ;
28434 PyObject *swig_obj[1] ;
28435
28436 if (!args) SWIG_fail;
28437 swig_obj[0] = args;
28438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28439 if (!SWIG_IsOK(res1)) {
28440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28441 }
28442 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 result = (bool)(arg1)->Dispatch();
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 PyObject *resultobj = 0;
28460 wxPyApp *arg1 = (wxPyApp *) 0 ;
28461 bool result;
28462 void *argp1 = 0 ;
28463 int res1 = 0 ;
28464 PyObject *swig_obj[1] ;
28465
28466 if (!args) SWIG_fail;
28467 swig_obj[0] = args;
28468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28469 if (!SWIG_IsOK(res1)) {
28470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28471 }
28472 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (bool)(arg1)->ProcessIdle();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 {
28480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28481 }
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28489 PyObject *resultobj = 0;
28490 wxPyApp *arg1 = (wxPyApp *) 0 ;
28491 wxWindow *arg2 = (wxWindow *) 0 ;
28492 wxIdleEvent *arg3 = 0 ;
28493 bool result;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 void *argp2 = 0 ;
28497 int res2 = 0 ;
28498 void *argp3 = 0 ;
28499 int res3 = 0 ;
28500 PyObject * obj0 = 0 ;
28501 PyObject * obj1 = 0 ;
28502 PyObject * obj2 = 0 ;
28503 char * kwnames[] = {
28504 (char *) "self",(char *) "win",(char *) "event", NULL
28505 };
28506
28507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28511 }
28512 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28514 if (!SWIG_IsOK(res2)) {
28515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28516 }
28517 arg2 = reinterpret_cast< wxWindow * >(argp2);
28518 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28519 if (!SWIG_IsOK(res3)) {
28520 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28521 }
28522 if (!argp3) {
28523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28524 }
28525 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28534 }
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28542 PyObject *resultobj = 0;
28543 wxPyApp *arg1 = (wxPyApp *) 0 ;
28544 bool result;
28545 void *argp1 = 0 ;
28546 int res1 = 0 ;
28547 PyObject *swig_obj[1] ;
28548
28549 if (!args) SWIG_fail;
28550 swig_obj[0] = args;
28551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28554 }
28555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (bool)((wxPyApp const *)arg1)->IsActive();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 {
28563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj = 0;
28573 wxPyApp *arg1 = (wxPyApp *) 0 ;
28574 wxWindow *arg2 = (wxWindow *) 0 ;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 void *argp2 = 0 ;
28578 int res2 = 0 ;
28579 PyObject * obj0 = 0 ;
28580 PyObject * obj1 = 0 ;
28581 char * kwnames[] = {
28582 (char *) "self",(char *) "win", NULL
28583 };
28584
28585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28587 if (!SWIG_IsOK(res1)) {
28588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28589 }
28590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28592 if (!SWIG_IsOK(res2)) {
28593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28594 }
28595 arg2 = reinterpret_cast< wxWindow * >(argp2);
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 (arg1)->SetTopWindow(arg2);
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 resultobj = SWIG_Py_Void();
28603 return resultobj;
28604 fail:
28605 return NULL;
28606 }
28607
28608
28609 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28610 PyObject *resultobj = 0;
28611 wxPyApp *arg1 = (wxPyApp *) 0 ;
28612 wxWindow *result = 0 ;
28613 void *argp1 = 0 ;
28614 int res1 = 0 ;
28615 PyObject *swig_obj[1] ;
28616
28617 if (!args) SWIG_fail;
28618 swig_obj[0] = args;
28619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28620 if (!SWIG_IsOK(res1)) {
28621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28622 }
28623 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28624 {
28625 PyThreadState* __tstate = wxPyBeginAllowThreads();
28626 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = wxPyMake_wxObject(result, (bool)0);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj = 0;
28641 wxPyApp *arg1 = (wxPyApp *) 0 ;
28642 bool arg2 ;
28643 void *argp1 = 0 ;
28644 int res1 = 0 ;
28645 bool val2 ;
28646 int ecode2 = 0 ;
28647 PyObject * obj0 = 0 ;
28648 PyObject * obj1 = 0 ;
28649 char * kwnames[] = {
28650 (char *) "self",(char *) "flag", NULL
28651 };
28652
28653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28657 }
28658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28659 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28660 if (!SWIG_IsOK(ecode2)) {
28661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28662 }
28663 arg2 = static_cast< bool >(val2);
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 (arg1)->SetExitOnFrameDelete(arg2);
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 resultobj = SWIG_Py_Void();
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28678 PyObject *resultobj = 0;
28679 wxPyApp *arg1 = (wxPyApp *) 0 ;
28680 bool result;
28681 void *argp1 = 0 ;
28682 int res1 = 0 ;
28683 PyObject *swig_obj[1] ;
28684
28685 if (!args) SWIG_fail;
28686 swig_obj[0] = args;
28687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28688 if (!SWIG_IsOK(res1)) {
28689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28690 }
28691 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28692 {
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 {
28699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28700 }
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28708 PyObject *resultobj = 0;
28709 wxPyApp *arg1 = (wxPyApp *) 0 ;
28710 bool arg2 ;
28711 void *argp1 = 0 ;
28712 int res1 = 0 ;
28713 bool val2 ;
28714 int ecode2 = 0 ;
28715 PyObject * obj0 = 0 ;
28716 PyObject * obj1 = 0 ;
28717 char * kwnames[] = {
28718 (char *) "self",(char *) "flag", NULL
28719 };
28720
28721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28725 }
28726 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28728 if (!SWIG_IsOK(ecode2)) {
28729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28730 }
28731 arg2 = static_cast< bool >(val2);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 (arg1)->SetUseBestVisual(arg2);
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_Py_Void();
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28746 PyObject *resultobj = 0;
28747 wxPyApp *arg1 = (wxPyApp *) 0 ;
28748 bool result;
28749 void *argp1 = 0 ;
28750 int res1 = 0 ;
28751 PyObject *swig_obj[1] ;
28752
28753 if (!args) SWIG_fail;
28754 swig_obj[0] = args;
28755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28756 if (!SWIG_IsOK(res1)) {
28757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28758 }
28759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 {
28767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28768 }
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj = 0;
28777 wxPyApp *arg1 = (wxPyApp *) 0 ;
28778 int arg2 ;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 int val2 ;
28782 int ecode2 = 0 ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 char * kwnames[] = {
28786 (char *) "self",(char *) "mode", NULL
28787 };
28788
28789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28793 }
28794 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28795 ecode2 = SWIG_AsVal_int(obj1, &val2);
28796 if (!SWIG_IsOK(ecode2)) {
28797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28798 }
28799 arg2 = static_cast< int >(val2);
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 (arg1)->SetPrintMode(arg2);
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_Py_Void();
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28814 PyObject *resultobj = 0;
28815 wxPyApp *arg1 = (wxPyApp *) 0 ;
28816 int result;
28817 void *argp1 = 0 ;
28818 int res1 = 0 ;
28819 PyObject *swig_obj[1] ;
28820
28821 if (!args) SWIG_fail;
28822 swig_obj[0] = args;
28823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28824 if (!SWIG_IsOK(res1)) {
28825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28826 }
28827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_From_int(static_cast< int >(result));
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj = 0;
28843 wxPyApp *arg1 = (wxPyApp *) 0 ;
28844 int arg2 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 int val2 ;
28848 int ecode2 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 PyObject * obj1 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "self",(char *) "mode", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28859 }
28860 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28861 ecode2 = SWIG_AsVal_int(obj1, &val2);
28862 if (!SWIG_IsOK(ecode2)) {
28863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28864 }
28865 arg2 = static_cast< int >(val2);
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 (arg1)->SetAssertMode(arg2);
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 resultobj = SWIG_Py_Void();
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 PyObject *resultobj = 0;
28881 wxPyApp *arg1 = (wxPyApp *) 0 ;
28882 int result;
28883 void *argp1 = 0 ;
28884 int res1 = 0 ;
28885 PyObject *swig_obj[1] ;
28886
28887 if (!args) SWIG_fail;
28888 swig_obj[0] = args;
28889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28892 }
28893 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (int)(arg1)->GetAssertMode();
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 resultobj = SWIG_From_int(static_cast< int >(result));
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908 PyObject *resultobj = 0;
28909 bool result;
28910
28911 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 {
28919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28920 }
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 long result;
28930
28931 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28932 {
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = (long)wxPyApp::GetMacAboutMenuItemId();
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_From_long(static_cast< long >(result));
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28946 PyObject *resultobj = 0;
28947 long result;
28948
28949 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_From_long(static_cast< long >(result));
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28964 PyObject *resultobj = 0;
28965 long result;
28966
28967 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (long)wxPyApp::GetMacExitMenuItemId();
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 resultobj = SWIG_From_long(static_cast< long >(result));
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28982 PyObject *resultobj = 0;
28983 wxString result;
28984
28985 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = wxPyApp::GetMacHelpMenuTitleName();
28989 wxPyEndAllowThreads(__tstate);
28990 if (PyErr_Occurred()) SWIG_fail;
28991 }
28992 {
28993 #if wxUSE_UNICODE
28994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28995 #else
28996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28997 #endif
28998 }
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj = 0;
29007 bool arg1 ;
29008 bool val1 ;
29009 int ecode1 = 0 ;
29010 PyObject * obj0 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "val", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29016 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29017 if (!SWIG_IsOK(ecode1)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29019 }
29020 arg1 = static_cast< bool >(val1);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_Py_Void();
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 long arg1 ;
29037 long val1 ;
29038 int ecode1 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "val", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29045 ecode1 = SWIG_AsVal_long(obj0, &val1);
29046 if (!SWIG_IsOK(ecode1)) {
29047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29048 }
29049 arg1 = static_cast< long >(val1);
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 wxPyApp::SetMacAboutMenuItemId(arg1);
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_Py_Void();
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj = 0;
29065 long arg1 ;
29066 long val1 ;
29067 int ecode1 = 0 ;
29068 PyObject * obj0 = 0 ;
29069 char * kwnames[] = {
29070 (char *) "val", NULL
29071 };
29072
29073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29074 ecode1 = SWIG_AsVal_long(obj0, &val1);
29075 if (!SWIG_IsOK(ecode1)) {
29076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29077 }
29078 arg1 = static_cast< long >(val1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 resultobj = SWIG_Py_Void();
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj = 0;
29094 long arg1 ;
29095 long val1 ;
29096 int ecode1 = 0 ;
29097 PyObject * obj0 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "val", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29103 ecode1 = SWIG_AsVal_long(obj0, &val1);
29104 if (!SWIG_IsOK(ecode1)) {
29105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29106 }
29107 arg1 = static_cast< long >(val1);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 wxPyApp::SetMacExitMenuItemId(arg1);
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_Py_Void();
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 wxString *arg1 = 0 ;
29124 bool temp1 = false ;
29125 PyObject * obj0 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "val", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29131 {
29132 arg1 = wxString_in_helper(obj0);
29133 if (arg1 == NULL) SWIG_fail;
29134 temp1 = true;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 resultobj = SWIG_Py_Void();
29143 {
29144 if (temp1)
29145 delete arg1;
29146 }
29147 return resultobj;
29148 fail:
29149 {
29150 if (temp1)
29151 delete arg1;
29152 }
29153 return NULL;
29154 }
29155
29156
29157 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29158 PyObject *resultobj = 0;
29159 wxPyApp *arg1 = (wxPyApp *) 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 PyObject *swig_obj[1] ;
29163
29164 if (!args) SWIG_fail;
29165 swig_obj[0] = args;
29166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29169 }
29170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 (arg1)->_BootstrapApp();
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_Py_Void();
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 int result;
29187
29188 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (int)wxPyApp::GetComCtl32Version();
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int(static_cast< int >(result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *resultobj = 0;
29204 bool result;
29205
29206 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 result = (bool)wxPyApp_IsDisplayAvailable();
29210 wxPyEndAllowThreads(__tstate);
29211 if (PyErr_Occurred()) SWIG_fail;
29212 }
29213 {
29214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29215 }
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *obj;
29224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29226 return SWIG_Py_Void();
29227 }
29228
29229 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 return SWIG_Python_InitShadowInstance(args);
29231 }
29232
29233 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235
29236 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 wxExit();
29240 wxPyEndAllowThreads(__tstate);
29241 if (PyErr_Occurred()) SWIG_fail;
29242 }
29243 resultobj = SWIG_Py_Void();
29244 return resultobj;
29245 fail:
29246 return NULL;
29247 }
29248
29249
29250 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29251 PyObject *resultobj = 0;
29252 bool result;
29253
29254 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 result = (bool)wxYield();
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 {
29262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29263 }
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 bool result;
29273
29274 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 result = (bool)wxYieldIfNeeded();
29278 wxPyEndAllowThreads(__tstate);
29279 if (PyErr_Occurred()) SWIG_fail;
29280 }
29281 {
29282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29283 }
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj = 0;
29292 wxWindow *arg1 = (wxWindow *) NULL ;
29293 bool arg2 = (bool) false ;
29294 bool result;
29295 void *argp1 = 0 ;
29296 int res1 = 0 ;
29297 bool val2 ;
29298 int ecode2 = 0 ;
29299 PyObject * obj0 = 0 ;
29300 PyObject * obj1 = 0 ;
29301 char * kwnames[] = {
29302 (char *) "win",(char *) "onlyIfNeeded", NULL
29303 };
29304
29305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29306 if (obj0) {
29307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29308 if (!SWIG_IsOK(res1)) {
29309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29310 }
29311 arg1 = reinterpret_cast< wxWindow * >(argp1);
29312 }
29313 if (obj1) {
29314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29315 if (!SWIG_IsOK(ecode2)) {
29316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29317 }
29318 arg2 = static_cast< bool >(val2);
29319 }
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 result = (bool)wxSafeYield(arg1,arg2);
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 {
29327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29328 }
29329 return resultobj;
29330 fail:
29331 return NULL;
29332 }
29333
29334
29335 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29336 PyObject *resultobj = 0;
29337
29338 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 wxWakeUpIdle();
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_Py_Void();
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = 0;
29354 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29355 wxEvent *arg2 = 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 void *argp2 = 0 ;
29359 int res2 = 0 ;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "dest",(char *) "event", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29370 }
29371 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29373 if (!SWIG_IsOK(res2)) {
29374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29375 }
29376 if (!argp2) {
29377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29378 }
29379 arg2 = reinterpret_cast< wxEvent * >(argp2);
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 wxPostEvent(arg1,*arg2);
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_Py_Void();
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395
29396 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 wxApp_CleanUp();
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 resultobj = SWIG_Py_Void();
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29411 PyObject *resultobj = 0;
29412 wxPyApp *result = 0 ;
29413
29414 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (wxPyApp *)wxPyGetApp();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 {
29422 resultobj = wxPyMake_wxObject(result, 0);
29423 }
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj = 0;
29432 char *arg1 = (char *) 0 ;
29433 int res1 ;
29434 char *buf1 = 0 ;
29435 int alloc1 = 0 ;
29436 PyObject * obj0 = 0 ;
29437 char * kwnames[] = {
29438 (char *) "encoding", NULL
29439 };
29440
29441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29442 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29445 }
29446 arg1 = buf1;
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 wxSetDefaultPyEncoding((char const *)arg1);
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 resultobj = SWIG_Py_Void();
29454 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29455 return resultobj;
29456 fail:
29457 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29463 PyObject *resultobj = 0;
29464 char *result = 0 ;
29465
29466 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 result = (char *)wxGetDefaultPyEncoding();
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 resultobj = SWIG_FromCharPtr(result);
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29481 PyObject *resultobj = 0;
29482 wxEventLoop *result = 0 ;
29483
29484 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (wxEventLoop *)new wxEventLoop();
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29499 PyObject *resultobj = 0;
29500 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 PyObject *swig_obj[1] ;
29504
29505 if (!args) SWIG_fail;
29506 swig_obj[0] = args;
29507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29508 if (!SWIG_IsOK(res1)) {
29509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29510 }
29511 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29512 {
29513 PyThreadState* __tstate = wxPyBeginAllowThreads();
29514 delete arg1;
29515
29516 wxPyEndAllowThreads(__tstate);
29517 if (PyErr_Occurred()) SWIG_fail;
29518 }
29519 resultobj = SWIG_Py_Void();
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29527 PyObject *resultobj = 0;
29528 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29529 int result;
29530 void *argp1 = 0 ;
29531 int res1 = 0 ;
29532 PyObject *swig_obj[1] ;
29533
29534 if (!args) SWIG_fail;
29535 swig_obj[0] = args;
29536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29537 if (!SWIG_IsOK(res1)) {
29538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29539 }
29540 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 result = (int)(arg1)->Run();
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 resultobj = SWIG_From_int(static_cast< int >(result));
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj = 0;
29556 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29557 int arg2 = (int) 0 ;
29558 void *argp1 = 0 ;
29559 int res1 = 0 ;
29560 int val2 ;
29561 int ecode2 = 0 ;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 char * kwnames[] = {
29565 (char *) "self",(char *) "rc", NULL
29566 };
29567
29568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29570 if (!SWIG_IsOK(res1)) {
29571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29572 }
29573 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29574 if (obj1) {
29575 ecode2 = SWIG_AsVal_int(obj1, &val2);
29576 if (!SWIG_IsOK(ecode2)) {
29577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29578 }
29579 arg2 = static_cast< int >(val2);
29580 }
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 (arg1)->Exit(arg2);
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 resultobj = SWIG_Py_Void();
29588 return resultobj;
29589 fail:
29590 return NULL;
29591 }
29592
29593
29594 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29595 PyObject *resultobj = 0;
29596 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29597 bool result;
29598 void *argp1 = 0 ;
29599 int res1 = 0 ;
29600 PyObject *swig_obj[1] ;
29601
29602 if (!args) SWIG_fail;
29603 swig_obj[0] = args;
29604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29605 if (!SWIG_IsOK(res1)) {
29606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29607 }
29608 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)((wxEventLoop const *)arg1)->Pending();
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 {
29616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29617 }
29618 return resultobj;
29619 fail:
29620 return NULL;
29621 }
29622
29623
29624 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29625 PyObject *resultobj = 0;
29626 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 PyObject *swig_obj[1] ;
29631
29632 if (!args) SWIG_fail;
29633 swig_obj[0] = args;
29634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29635 if (!SWIG_IsOK(res1)) {
29636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29637 }
29638 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29639 {
29640 PyThreadState* __tstate = wxPyBeginAllowThreads();
29641 result = (bool)(arg1)->Dispatch();
29642 wxPyEndAllowThreads(__tstate);
29643 if (PyErr_Occurred()) SWIG_fail;
29644 }
29645 {
29646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29647 }
29648 return resultobj;
29649 fail:
29650 return NULL;
29651 }
29652
29653
29654 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29655 PyObject *resultobj = 0;
29656 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29657 bool result;
29658 void *argp1 = 0 ;
29659 int res1 = 0 ;
29660 PyObject *swig_obj[1] ;
29661
29662 if (!args) SWIG_fail;
29663 swig_obj[0] = args;
29664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29665 if (!SWIG_IsOK(res1)) {
29666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29667 }
29668 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 {
29676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29677 }
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29685 PyObject *resultobj = 0;
29686 wxEventLoop *result = 0 ;
29687
29688 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 result = (wxEventLoop *)wxEventLoop::GetActive();
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj = 0;
29704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 PyObject * obj0 = 0 ;
29708 char * kwnames[] = {
29709 (char *) "loop", NULL
29710 };
29711
29712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29714 if (!SWIG_IsOK(res1)) {
29715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29716 }
29717 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 wxEventLoop::SetActive(arg1);
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 resultobj = SWIG_Py_Void();
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29732 PyObject *obj;
29733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29734 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29735 return SWIG_Py_Void();
29736 }
29737
29738 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29739 return SWIG_Python_InitShadowInstance(args);
29740 }
29741
29742 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj = 0;
29744 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29745 wxEventLoopActivator *result = 0 ;
29746 void *argp1 = 0 ;
29747 int res1 = 0 ;
29748 PyObject * obj0 = 0 ;
29749 char * kwnames[] = {
29750 (char *) "evtLoop", NULL
29751 };
29752
29753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29755 if (!SWIG_IsOK(res1)) {
29756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29757 }
29758 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29759 {
29760 PyThreadState* __tstate = wxPyBeginAllowThreads();
29761 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29766 return resultobj;
29767 fail:
29768 return NULL;
29769 }
29770
29771
29772 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29773 PyObject *resultobj = 0;
29774 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29775 void *argp1 = 0 ;
29776 int res1 = 0 ;
29777 PyObject *swig_obj[1] ;
29778
29779 if (!args) SWIG_fail;
29780 swig_obj[0] = args;
29781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29784 }
29785 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 delete arg1;
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_Py_Void();
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29801 PyObject *obj;
29802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29803 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29804 return SWIG_Py_Void();
29805 }
29806
29807 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29808 return SWIG_Python_InitShadowInstance(args);
29809 }
29810
29811 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj = 0;
29813 int arg1 = (int) 0 ;
29814 int arg2 = (int) 0 ;
29815 int arg3 = (int) 0 ;
29816 wxAcceleratorEntry *result = 0 ;
29817 int val1 ;
29818 int ecode1 = 0 ;
29819 int val2 ;
29820 int ecode2 = 0 ;
29821 int val3 ;
29822 int ecode3 = 0 ;
29823 PyObject * obj0 = 0 ;
29824 PyObject * obj1 = 0 ;
29825 PyObject * obj2 = 0 ;
29826 char * kwnames[] = {
29827 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29828 };
29829
29830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29831 if (obj0) {
29832 ecode1 = SWIG_AsVal_int(obj0, &val1);
29833 if (!SWIG_IsOK(ecode1)) {
29834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29835 }
29836 arg1 = static_cast< int >(val1);
29837 }
29838 if (obj1) {
29839 ecode2 = SWIG_AsVal_int(obj1, &val2);
29840 if (!SWIG_IsOK(ecode2)) {
29841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29842 }
29843 arg2 = static_cast< int >(val2);
29844 }
29845 if (obj2) {
29846 ecode3 = SWIG_AsVal_int(obj2, &val3);
29847 if (!SWIG_IsOK(ecode3)) {
29848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29849 }
29850 arg3 = static_cast< int >(val3);
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29866 PyObject *resultobj = 0;
29867 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 PyObject *swig_obj[1] ;
29871
29872 if (!args) SWIG_fail;
29873 swig_obj[0] = args;
29874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29875 if (!SWIG_IsOK(res1)) {
29876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29877 }
29878 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 delete arg1;
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 resultobj = SWIG_Py_Void();
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj = 0;
29895 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29896 int arg2 ;
29897 int arg3 ;
29898 int arg4 ;
29899 void *argp1 = 0 ;
29900 int res1 = 0 ;
29901 int val2 ;
29902 int ecode2 = 0 ;
29903 int val3 ;
29904 int ecode3 = 0 ;
29905 int val4 ;
29906 int ecode4 = 0 ;
29907 PyObject * obj0 = 0 ;
29908 PyObject * obj1 = 0 ;
29909 PyObject * obj2 = 0 ;
29910 PyObject * obj3 = 0 ;
29911 char * kwnames[] = {
29912 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29913 };
29914
29915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29917 if (!SWIG_IsOK(res1)) {
29918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29919 }
29920 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29921 ecode2 = SWIG_AsVal_int(obj1, &val2);
29922 if (!SWIG_IsOK(ecode2)) {
29923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29924 }
29925 arg2 = static_cast< int >(val2);
29926 ecode3 = SWIG_AsVal_int(obj2, &val3);
29927 if (!SWIG_IsOK(ecode3)) {
29928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29929 }
29930 arg3 = static_cast< int >(val3);
29931 ecode4 = SWIG_AsVal_int(obj3, &val4);
29932 if (!SWIG_IsOK(ecode4)) {
29933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29934 }
29935 arg4 = static_cast< int >(val4);
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 (arg1)->Set(arg2,arg3,arg4);
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 resultobj = SWIG_Py_Void();
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29950 PyObject *resultobj = 0;
29951 wxString *arg1 = 0 ;
29952 wxAcceleratorEntry *result = 0 ;
29953 bool temp1 = false ;
29954 PyObject * obj0 = 0 ;
29955 char * kwnames[] = {
29956 (char *) "str", NULL
29957 };
29958
29959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29960 {
29961 arg1 = wxString_in_helper(obj0);
29962 if (arg1 == NULL) SWIG_fail;
29963 temp1 = true;
29964 }
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29972 {
29973 if (temp1)
29974 delete arg1;
29975 }
29976 return resultobj;
29977 fail:
29978 {
29979 if (temp1)
29980 delete arg1;
29981 }
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29987 PyObject *resultobj = 0;
29988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29989 int result;
29990 void *argp1 = 0 ;
29991 int res1 = 0 ;
29992 PyObject *swig_obj[1] ;
29993
29994 if (!args) SWIG_fail;
29995 swig_obj[0] = args;
29996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29997 if (!SWIG_IsOK(res1)) {
29998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29999 }
30000 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = (int)(arg1)->GetFlags();
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 resultobj = SWIG_From_int(static_cast< int >(result));
30008 return resultobj;
30009 fail:
30010 return NULL;
30011 }
30012
30013
30014 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30015 PyObject *resultobj = 0;
30016 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30017 int result;
30018 void *argp1 = 0 ;
30019 int res1 = 0 ;
30020 PyObject *swig_obj[1] ;
30021
30022 if (!args) SWIG_fail;
30023 swig_obj[0] = args;
30024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30025 if (!SWIG_IsOK(res1)) {
30026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30027 }
30028 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (int)(arg1)->GetKeyCode();
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 resultobj = SWIG_From_int(static_cast< int >(result));
30036 return resultobj;
30037 fail:
30038 return NULL;
30039 }
30040
30041
30042 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30043 PyObject *resultobj = 0;
30044 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30045 int result;
30046 void *argp1 = 0 ;
30047 int res1 = 0 ;
30048 PyObject *swig_obj[1] ;
30049
30050 if (!args) SWIG_fail;
30051 swig_obj[0] = args;
30052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30055 }
30056 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = (int)(arg1)->GetCommand();
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_From_int(static_cast< int >(result));
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30073 bool result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 PyObject *swig_obj[1] ;
30077
30078 if (!args) SWIG_fail;
30079 swig_obj[0] = args;
30080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30083 }
30084 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30103 wxString result;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 PyObject *swig_obj[1] ;
30107
30108 if (!args) SWIG_fail;
30109 swig_obj[0] = args;
30110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30113 }
30114 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 {
30122 #if wxUSE_UNICODE
30123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30124 #else
30125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30126 #endif
30127 }
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = 0;
30136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30137 wxString *arg2 = 0 ;
30138 bool result;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 bool temp2 = false ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 char * kwnames[] = {
30145 (char *) "self",(char *) "str", NULL
30146 };
30147
30148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30152 }
30153 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30154 {
30155 arg2 = wxString_in_helper(obj1);
30156 if (arg2 == NULL) SWIG_fail;
30157 temp2 = true;
30158 }
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 {
30166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30167 }
30168 {
30169 if (temp2)
30170 delete arg2;
30171 }
30172 return resultobj;
30173 fail:
30174 {
30175 if (temp2)
30176 delete arg2;
30177 }
30178 return NULL;
30179 }
30180
30181
30182 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30183 PyObject *obj;
30184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30185 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30186 return SWIG_Py_Void();
30187 }
30188
30189 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30190 return SWIG_Python_InitShadowInstance(args);
30191 }
30192
30193 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj = 0;
30195 int arg1 ;
30196 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30197 wxAcceleratorTable *result = 0 ;
30198 PyObject * obj0 = 0 ;
30199 char * kwnames[] = {
30200 (char *) "n", NULL
30201 };
30202
30203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30204 {
30205 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30206 if (arg2) arg1 = PyList_Size(obj0);
30207 else arg1 = 0;
30208 }
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 PyObject *swig_obj[1] ;
30228
30229 if (!args) SWIG_fail;
30230 swig_obj[0] = args;
30231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30232 if (!SWIG_IsOK(res1)) {
30233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30234 }
30235 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 delete arg1;
30239
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_Py_Void();
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30253 bool result;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 PyObject *swig_obj[1] ;
30257
30258 if (!args) SWIG_fail;
30259 swig_obj[0] = args;
30260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30261 if (!SWIG_IsOK(res1)) {
30262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30263 }
30264 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 {
30272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30273 }
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30281 PyObject *obj;
30282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30283 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30284 return SWIG_Py_Void();
30285 }
30286
30287 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30288 return SWIG_Python_InitShadowInstance(args);
30289 }
30290
30291 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30292 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30293 return 1;
30294 }
30295
30296
30297 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30298 PyObject *pyobj = 0;
30299
30300 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30301 return pyobj;
30302 }
30303
30304
30305 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30306 PyObject *resultobj = 0;
30307 wxString *arg1 = 0 ;
30308 wxAcceleratorEntry *result = 0 ;
30309 bool temp1 = false ;
30310 PyObject * obj0 = 0 ;
30311 char * kwnames[] = {
30312 (char *) "label", NULL
30313 };
30314
30315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30316 {
30317 arg1 = wxString_in_helper(obj0);
30318 if (arg1 == NULL) SWIG_fail;
30319 temp1 = true;
30320 }
30321 {
30322 PyThreadState* __tstate = wxPyBeginAllowThreads();
30323 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30324 wxPyEndAllowThreads(__tstate);
30325 if (PyErr_Occurred()) SWIG_fail;
30326 }
30327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30328 {
30329 if (temp1)
30330 delete arg1;
30331 }
30332 return resultobj;
30333 fail:
30334 {
30335 if (temp1)
30336 delete arg1;
30337 }
30338 return NULL;
30339 }
30340
30341
30342 SWIGINTERN int PanelNameStr_set(PyObject *) {
30343 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30344 return 1;
30345 }
30346
30347
30348 SWIGINTERN PyObject *PanelNameStr_get(void) {
30349 PyObject *pyobj = 0;
30350
30351 {
30352 #if wxUSE_UNICODE
30353 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30354 #else
30355 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30356 #endif
30357 }
30358 return pyobj;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 wxVisualAttributes *result = 0 ;
30365
30366 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (wxVisualAttributes *)new_wxVisualAttributes();
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30381 PyObject *resultobj = 0;
30382 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30383 void *argp1 = 0 ;
30384 int res1 = 0 ;
30385 PyObject *swig_obj[1] ;
30386
30387 if (!args) SWIG_fail;
30388 swig_obj[0] = args;
30389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30392 }
30393 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 delete_wxVisualAttributes(arg1);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 resultobj = SWIG_Py_Void();
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30409 PyObject *resultobj = 0;
30410 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30411 wxFont *arg2 = (wxFont *) 0 ;
30412 void *argp1 = 0 ;
30413 int res1 = 0 ;
30414 void *argp2 = 0 ;
30415 int res2 = 0 ;
30416 PyObject *swig_obj[2] ;
30417
30418 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30420 if (!SWIG_IsOK(res1)) {
30421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30422 }
30423 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30425 if (!SWIG_IsOK(res2)) {
30426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30427 }
30428 arg2 = reinterpret_cast< wxFont * >(argp2);
30429 if (arg1) (arg1)->font = *arg2;
30430
30431 resultobj = SWIG_Py_Void();
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30439 PyObject *resultobj = 0;
30440 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30441 wxFont *result = 0 ;
30442 void *argp1 = 0 ;
30443 int res1 = 0 ;
30444 PyObject *swig_obj[1] ;
30445
30446 if (!args) SWIG_fail;
30447 swig_obj[0] = args;
30448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30449 if (!SWIG_IsOK(res1)) {
30450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30451 }
30452 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30453 result = (wxFont *)& ((arg1)->font);
30454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30464 wxColour *arg2 = (wxColour *) 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 void *argp2 = 0 ;
30468 int res2 = 0 ;
30469 PyObject *swig_obj[2] ;
30470
30471 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30473 if (!SWIG_IsOK(res1)) {
30474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30475 }
30476 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30477 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30478 if (!SWIG_IsOK(res2)) {
30479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30480 }
30481 arg2 = reinterpret_cast< wxColour * >(argp2);
30482 if (arg1) (arg1)->colFg = *arg2;
30483
30484 resultobj = SWIG_Py_Void();
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30492 PyObject *resultobj = 0;
30493 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30494 wxColour *result = 0 ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 PyObject *swig_obj[1] ;
30498
30499 if (!args) SWIG_fail;
30500 swig_obj[0] = args;
30501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30504 }
30505 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30506 result = (wxColour *)& ((arg1)->colFg);
30507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30515 PyObject *resultobj = 0;
30516 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30517 wxColour *arg2 = (wxColour *) 0 ;
30518 void *argp1 = 0 ;
30519 int res1 = 0 ;
30520 void *argp2 = 0 ;
30521 int res2 = 0 ;
30522 PyObject *swig_obj[2] ;
30523
30524 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30526 if (!SWIG_IsOK(res1)) {
30527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30528 }
30529 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30530 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30531 if (!SWIG_IsOK(res2)) {
30532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30533 }
30534 arg2 = reinterpret_cast< wxColour * >(argp2);
30535 if (arg1) (arg1)->colBg = *arg2;
30536
30537 resultobj = SWIG_Py_Void();
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30545 PyObject *resultobj = 0;
30546 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30547 wxColour *result = 0 ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 PyObject *swig_obj[1] ;
30551
30552 if (!args) SWIG_fail;
30553 swig_obj[0] = args;
30554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30555 if (!SWIG_IsOK(res1)) {
30556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30557 }
30558 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30559 result = (wxColour *)& ((arg1)->colBg);
30560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30568 PyObject *obj;
30569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30570 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30571 return SWIG_Py_Void();
30572 }
30573
30574 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30575 return SWIG_Python_InitShadowInstance(args);
30576 }
30577
30578 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj = 0;
30580 wxWindow *arg1 = (wxWindow *) 0 ;
30581 int arg2 = (int) (int)-1 ;
30582 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30583 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30584 wxSize const &arg4_defvalue = wxDefaultSize ;
30585 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30586 long arg5 = (long) 0 ;
30587 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30588 wxString *arg6 = (wxString *) &arg6_defvalue ;
30589 wxWindow *result = 0 ;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 int val2 ;
30593 int ecode2 = 0 ;
30594 wxPoint temp3 ;
30595 wxSize temp4 ;
30596 long val5 ;
30597 int ecode5 = 0 ;
30598 bool temp6 = false ;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 PyObject * obj2 = 0 ;
30602 PyObject * obj3 = 0 ;
30603 PyObject * obj4 = 0 ;
30604 PyObject * obj5 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 if (obj1) {
30616 ecode2 = SWIG_AsVal_int(obj1, &val2);
30617 if (!SWIG_IsOK(ecode2)) {
30618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30619 }
30620 arg2 = static_cast< int >(val2);
30621 }
30622 if (obj2) {
30623 {
30624 arg3 = &temp3;
30625 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30626 }
30627 }
30628 if (obj3) {
30629 {
30630 arg4 = &temp4;
30631 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30632 }
30633 }
30634 if (obj4) {
30635 ecode5 = SWIG_AsVal_long(obj4, &val5);
30636 if (!SWIG_IsOK(ecode5)) {
30637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30638 }
30639 arg5 = static_cast< long >(val5);
30640 }
30641 if (obj5) {
30642 {
30643 arg6 = wxString_in_helper(obj5);
30644 if (arg6 == NULL) SWIG_fail;
30645 temp6 = true;
30646 }
30647 }
30648 {
30649 if (!wxPyCheckForApp()) SWIG_fail;
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30656 {
30657 if (temp6)
30658 delete arg6;
30659 }
30660 return resultobj;
30661 fail:
30662 {
30663 if (temp6)
30664 delete arg6;
30665 }
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 PyObject *resultobj = 0;
30672 wxWindow *result = 0 ;
30673
30674 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30675 {
30676 if (!wxPyCheckForApp()) SWIG_fail;
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (wxWindow *)new wxWindow();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 wxWindow *arg2 = (wxWindow *) 0 ;
30693 int arg3 = (int) (int)-1 ;
30694 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30695 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30696 wxSize const &arg5_defvalue = wxDefaultSize ;
30697 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30698 long arg6 = (long) 0 ;
30699 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30700 wxString *arg7 = (wxString *) &arg7_defvalue ;
30701 bool result;
30702 void *argp1 = 0 ;
30703 int res1 = 0 ;
30704 void *argp2 = 0 ;
30705 int res2 = 0 ;
30706 int val3 ;
30707 int ecode3 = 0 ;
30708 wxPoint temp4 ;
30709 wxSize temp5 ;
30710 long val6 ;
30711 int ecode6 = 0 ;
30712 bool temp7 = false ;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 PyObject * obj2 = 0 ;
30716 PyObject * obj3 = 0 ;
30717 PyObject * obj4 = 0 ;
30718 PyObject * obj5 = 0 ;
30719 PyObject * obj6 = 0 ;
30720 char * kwnames[] = {
30721 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30722 };
30723
30724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30726 if (!SWIG_IsOK(res1)) {
30727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30728 }
30729 arg1 = reinterpret_cast< wxWindow * >(argp1);
30730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res2)) {
30732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30733 }
30734 arg2 = reinterpret_cast< wxWindow * >(argp2);
30735 if (obj2) {
30736 ecode3 = SWIG_AsVal_int(obj2, &val3);
30737 if (!SWIG_IsOK(ecode3)) {
30738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30739 }
30740 arg3 = static_cast< int >(val3);
30741 }
30742 if (obj3) {
30743 {
30744 arg4 = &temp4;
30745 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30746 }
30747 }
30748 if (obj4) {
30749 {
30750 arg5 = &temp5;
30751 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30752 }
30753 }
30754 if (obj5) {
30755 ecode6 = SWIG_AsVal_long(obj5, &val6);
30756 if (!SWIG_IsOK(ecode6)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30758 }
30759 arg6 = static_cast< long >(val6);
30760 }
30761 if (obj6) {
30762 {
30763 arg7 = wxString_in_helper(obj6);
30764 if (arg7 == NULL) SWIG_fail;
30765 temp7 = true;
30766 }
30767 }
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30776 }
30777 {
30778 if (temp7)
30779 delete arg7;
30780 }
30781 return resultobj;
30782 fail:
30783 {
30784 if (temp7)
30785 delete arg7;
30786 }
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 bool arg2 = (bool) false ;
30795 bool result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 bool val2 ;
30799 int ecode2 = 0 ;
30800 PyObject * obj0 = 0 ;
30801 PyObject * obj1 = 0 ;
30802 char * kwnames[] = {
30803 (char *) "self",(char *) "force", NULL
30804 };
30805
30806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30808 if (!SWIG_IsOK(res1)) {
30809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30810 }
30811 arg1 = reinterpret_cast< wxWindow * >(argp1);
30812 if (obj1) {
30813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30814 if (!SWIG_IsOK(ecode2)) {
30815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30816 }
30817 arg2 = static_cast< bool >(val2);
30818 }
30819 {
30820 PyThreadState* __tstate = wxPyBeginAllowThreads();
30821 result = (bool)(arg1)->Close(arg2);
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 {
30826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 bool result;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30847 }
30848 arg1 = reinterpret_cast< wxWindow * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (bool)(arg1)->Destroy();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 {
30856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 bool result;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 PyObject *swig_obj[1] ;
30871
30872 if (!args) SWIG_fail;
30873 swig_obj[0] = args;
30874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30875 if (!SWIG_IsOK(res1)) {
30876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30877 }
30878 arg1 = reinterpret_cast< wxWindow * >(argp1);
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 result = (bool)(arg1)->DestroyChildren();
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 {
30886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 bool result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 {
30916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30917 }
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj = 0;
30926 wxWindow *arg1 = (wxWindow *) 0 ;
30927 wxString *arg2 = 0 ;
30928 void *argp1 = 0 ;
30929 int res1 = 0 ;
30930 bool temp2 = false ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 char * kwnames[] = {
30934 (char *) "self",(char *) "label", NULL
30935 };
30936
30937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30939 if (!SWIG_IsOK(res1)) {
30940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30941 }
30942 arg1 = reinterpret_cast< wxWindow * >(argp1);
30943 {
30944 arg2 = wxString_in_helper(obj1);
30945 if (arg2 == NULL) SWIG_fail;
30946 temp2 = true;
30947 }
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 (arg1)->SetLabel((wxString const &)*arg2);
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 resultobj = SWIG_Py_Void();
30955 {
30956 if (temp2)
30957 delete arg2;
30958 }
30959 return resultobj;
30960 fail:
30961 {
30962 if (temp2)
30963 delete arg2;
30964 }
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30970 PyObject *resultobj = 0;
30971 wxWindow *arg1 = (wxWindow *) 0 ;
30972 wxString result;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 PyObject *swig_obj[1] ;
30976
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = ((wxWindow const *)arg1)->GetLabel();
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 {
30991 #if wxUSE_UNICODE
30992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30993 #else
30994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30995 #endif
30996 }
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj = 0;
31005 wxWindow *arg1 = (wxWindow *) 0 ;
31006 wxString *arg2 = 0 ;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 bool temp2 = false ;
31010 PyObject * obj0 = 0 ;
31011 PyObject * obj1 = 0 ;
31012 char * kwnames[] = {
31013 (char *) "self",(char *) "name", NULL
31014 };
31015
31016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31018 if (!SWIG_IsOK(res1)) {
31019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31020 }
31021 arg1 = reinterpret_cast< wxWindow * >(argp1);
31022 {
31023 arg2 = wxString_in_helper(obj1);
31024 if (arg2 == NULL) SWIG_fail;
31025 temp2 = true;
31026 }
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 (arg1)->SetName((wxString const &)*arg2);
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_Py_Void();
31034 {
31035 if (temp2)
31036 delete arg2;
31037 }
31038 return resultobj;
31039 fail:
31040 {
31041 if (temp2)
31042 delete arg2;
31043 }
31044 return NULL;
31045 }
31046
31047
31048 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31049 PyObject *resultobj = 0;
31050 wxWindow *arg1 = (wxWindow *) 0 ;
31051 wxString result;
31052 void *argp1 = 0 ;
31053 int res1 = 0 ;
31054 PyObject *swig_obj[1] ;
31055
31056 if (!args) SWIG_fail;
31057 swig_obj[0] = args;
31058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31059 if (!SWIG_IsOK(res1)) {
31060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31061 }
31062 arg1 = reinterpret_cast< wxWindow * >(argp1);
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = ((wxWindow const *)arg1)->GetName();
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 {
31070 #if wxUSE_UNICODE
31071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31072 #else
31073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31074 #endif
31075 }
31076 return resultobj;
31077 fail:
31078 return NULL;
31079 }
31080
31081
31082 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31083 PyObject *resultobj = 0;
31084 wxWindow *arg1 = (wxWindow *) 0 ;
31085 wxWindowVariant arg2 ;
31086 void *argp1 = 0 ;
31087 int res1 = 0 ;
31088 int val2 ;
31089 int ecode2 = 0 ;
31090 PyObject * obj0 = 0 ;
31091 PyObject * obj1 = 0 ;
31092 char * kwnames[] = {
31093 (char *) "self",(char *) "variant", NULL
31094 };
31095
31096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31098 if (!SWIG_IsOK(res1)) {
31099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31100 }
31101 arg1 = reinterpret_cast< wxWindow * >(argp1);
31102 ecode2 = SWIG_AsVal_int(obj1, &val2);
31103 if (!SWIG_IsOK(ecode2)) {
31104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31105 }
31106 arg2 = static_cast< wxWindowVariant >(val2);
31107 {
31108 PyThreadState* __tstate = wxPyBeginAllowThreads();
31109 (arg1)->SetWindowVariant(arg2);
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 resultobj = SWIG_Py_Void();
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31121 PyObject *resultobj = 0;
31122 wxWindow *arg1 = (wxWindow *) 0 ;
31123 wxWindowVariant result;
31124 void *argp1 = 0 ;
31125 int res1 = 0 ;
31126 PyObject *swig_obj[1] ;
31127
31128 if (!args) SWIG_fail;
31129 swig_obj[0] = args;
31130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31133 }
31134 arg1 = reinterpret_cast< wxWindow * >(argp1);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_From_int(static_cast< int >(result));
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxWindow *arg1 = (wxWindow *) 0 ;
31151 int arg2 ;
31152 void *argp1 = 0 ;
31153 int res1 = 0 ;
31154 int val2 ;
31155 int ecode2 = 0 ;
31156 PyObject * obj0 = 0 ;
31157 PyObject * obj1 = 0 ;
31158 char * kwnames[] = {
31159 (char *) "self",(char *) "winid", NULL
31160 };
31161
31162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31164 if (!SWIG_IsOK(res1)) {
31165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31166 }
31167 arg1 = reinterpret_cast< wxWindow * >(argp1);
31168 ecode2 = SWIG_AsVal_int(obj1, &val2);
31169 if (!SWIG_IsOK(ecode2)) {
31170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31171 }
31172 arg2 = static_cast< int >(val2);
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 (arg1)->SetId(arg2);
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 resultobj = SWIG_Py_Void();
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31187 PyObject *resultobj = 0;
31188 wxWindow *arg1 = (wxWindow *) 0 ;
31189 int result;
31190 void *argp1 = 0 ;
31191 int res1 = 0 ;
31192 PyObject *swig_obj[1] ;
31193
31194 if (!args) SWIG_fail;
31195 swig_obj[0] = args;
31196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31197 if (!SWIG_IsOK(res1)) {
31198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (int)((wxWindow const *)arg1)->GetId();
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 resultobj = SWIG_From_int(static_cast< int >(result));
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 PyObject *resultobj = 0;
31216 int result;
31217
31218 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (int)wxWindow::NewControlId();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_From_int(static_cast< int >(result));
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 int arg1 ;
31235 int result;
31236 int val1 ;
31237 int ecode1 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 char * kwnames[] = {
31240 (char *) "winid", NULL
31241 };
31242
31243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31244 ecode1 = SWIG_AsVal_int(obj0, &val1);
31245 if (!SWIG_IsOK(ecode1)) {
31246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31247 }
31248 arg1 = static_cast< int >(val1);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = (int)wxWindow::NextControlId(arg1);
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_From_int(static_cast< int >(result));
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj = 0;
31264 int arg1 ;
31265 int result;
31266 int val1 ;
31267 int ecode1 = 0 ;
31268 PyObject * obj0 = 0 ;
31269 char * kwnames[] = {
31270 (char *) "winid", NULL
31271 };
31272
31273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31274 ecode1 = SWIG_AsVal_int(obj0, &val1);
31275 if (!SWIG_IsOK(ecode1)) {
31276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31277 }
31278 arg1 = static_cast< int >(val1);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = (int)wxWindow::PrevControlId(arg1);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_From_int(static_cast< int >(result));
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 wxLayoutDirection result;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 PyObject *swig_obj[1] ;
31299
31300 if (!args) SWIG_fail;
31301 swig_obj[0] = args;
31302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_From_int(static_cast< int >(result));
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj = 0;
31322 wxWindow *arg1 = (wxWindow *) 0 ;
31323 wxLayoutDirection arg2 ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 int val2 ;
31327 int ecode2 = 0 ;
31328 PyObject * obj0 = 0 ;
31329 PyObject * obj1 = 0 ;
31330 char * kwnames[] = {
31331 (char *) "self",(char *) "dir", NULL
31332 };
31333
31334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31336 if (!SWIG_IsOK(res1)) {
31337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31338 }
31339 arg1 = reinterpret_cast< wxWindow * >(argp1);
31340 ecode2 = SWIG_AsVal_int(obj1, &val2);
31341 if (!SWIG_IsOK(ecode2)) {
31342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31343 }
31344 arg2 = static_cast< wxLayoutDirection >(val2);
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 (arg1)->SetLayoutDirection(arg2);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj = 0;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 int arg2 ;
31362 int arg3 ;
31363 int arg4 ;
31364 int result;
31365 void *argp1 = 0 ;
31366 int res1 = 0 ;
31367 int val2 ;
31368 int ecode2 = 0 ;
31369 int val3 ;
31370 int ecode3 = 0 ;
31371 int val4 ;
31372 int ecode4 = 0 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 PyObject * obj2 = 0 ;
31376 PyObject * obj3 = 0 ;
31377 char * kwnames[] = {
31378 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31379 };
31380
31381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31383 if (!SWIG_IsOK(res1)) {
31384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31385 }
31386 arg1 = reinterpret_cast< wxWindow * >(argp1);
31387 ecode2 = SWIG_AsVal_int(obj1, &val2);
31388 if (!SWIG_IsOK(ecode2)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31390 }
31391 arg2 = static_cast< int >(val2);
31392 ecode3 = SWIG_AsVal_int(obj2, &val3);
31393 if (!SWIG_IsOK(ecode3)) {
31394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31395 }
31396 arg3 = static_cast< int >(val3);
31397 ecode4 = SWIG_AsVal_int(obj3, &val4);
31398 if (!SWIG_IsOK(ecode4)) {
31399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31400 }
31401 arg4 = static_cast< int >(val4);
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 resultobj = SWIG_From_int(static_cast< int >(result));
31409 return resultobj;
31410 fail:
31411 return NULL;
31412 }
31413
31414
31415 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31416 PyObject *resultobj = 0;
31417 wxWindow *arg1 = (wxWindow *) 0 ;
31418 wxSize *arg2 = 0 ;
31419 void *argp1 = 0 ;
31420 int res1 = 0 ;
31421 wxSize temp2 ;
31422 PyObject * obj0 = 0 ;
31423 PyObject * obj1 = 0 ;
31424 char * kwnames[] = {
31425 (char *) "self",(char *) "size", NULL
31426 };
31427
31428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31430 if (!SWIG_IsOK(res1)) {
31431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31432 }
31433 arg1 = reinterpret_cast< wxWindow * >(argp1);
31434 {
31435 arg2 = &temp2;
31436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31437 }
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 (arg1)->SetSize((wxSize const &)*arg2);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 resultobj = SWIG_Py_Void();
31445 return resultobj;
31446 fail:
31447 return NULL;
31448 }
31449
31450
31451 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31452 PyObject *resultobj = 0;
31453 wxWindow *arg1 = (wxWindow *) 0 ;
31454 int arg2 ;
31455 int arg3 ;
31456 int arg4 ;
31457 int arg5 ;
31458 int arg6 = (int) wxSIZE_AUTO ;
31459 void *argp1 = 0 ;
31460 int res1 = 0 ;
31461 int val2 ;
31462 int ecode2 = 0 ;
31463 int val3 ;
31464 int ecode3 = 0 ;
31465 int val4 ;
31466 int ecode4 = 0 ;
31467 int val5 ;
31468 int ecode5 = 0 ;
31469 int val6 ;
31470 int ecode6 = 0 ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 PyObject * obj2 = 0 ;
31474 PyObject * obj3 = 0 ;
31475 PyObject * obj4 = 0 ;
31476 PyObject * obj5 = 0 ;
31477 char * kwnames[] = {
31478 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31479 };
31480
31481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31485 }
31486 arg1 = reinterpret_cast< wxWindow * >(argp1);
31487 ecode2 = SWIG_AsVal_int(obj1, &val2);
31488 if (!SWIG_IsOK(ecode2)) {
31489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31490 }
31491 arg2 = static_cast< int >(val2);
31492 ecode3 = SWIG_AsVal_int(obj2, &val3);
31493 if (!SWIG_IsOK(ecode3)) {
31494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31495 }
31496 arg3 = static_cast< int >(val3);
31497 ecode4 = SWIG_AsVal_int(obj3, &val4);
31498 if (!SWIG_IsOK(ecode4)) {
31499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31500 }
31501 arg4 = static_cast< int >(val4);
31502 ecode5 = SWIG_AsVal_int(obj4, &val5);
31503 if (!SWIG_IsOK(ecode5)) {
31504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31505 }
31506 arg5 = static_cast< int >(val5);
31507 if (obj5) {
31508 ecode6 = SWIG_AsVal_int(obj5, &val6);
31509 if (!SWIG_IsOK(ecode6)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31511 }
31512 arg6 = static_cast< int >(val6);
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 resultobj = SWIG_Py_Void();
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31528 PyObject *resultobj = 0;
31529 wxWindow *arg1 = (wxWindow *) 0 ;
31530 wxRect *arg2 = 0 ;
31531 int arg3 = (int) wxSIZE_AUTO ;
31532 void *argp1 = 0 ;
31533 int res1 = 0 ;
31534 wxRect temp2 ;
31535 int val3 ;
31536 int ecode3 = 0 ;
31537 PyObject * obj0 = 0 ;
31538 PyObject * obj1 = 0 ;
31539 PyObject * obj2 = 0 ;
31540 char * kwnames[] = {
31541 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31542 };
31543
31544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31546 if (!SWIG_IsOK(res1)) {
31547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31548 }
31549 arg1 = reinterpret_cast< wxWindow * >(argp1);
31550 {
31551 arg2 = &temp2;
31552 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31553 }
31554 if (obj2) {
31555 ecode3 = SWIG_AsVal_int(obj2, &val3);
31556 if (!SWIG_IsOK(ecode3)) {
31557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31558 }
31559 arg3 = static_cast< int >(val3);
31560 }
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_Py_Void();
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj = 0;
31576 wxWindow *arg1 = (wxWindow *) 0 ;
31577 int arg2 ;
31578 int arg3 ;
31579 void *argp1 = 0 ;
31580 int res1 = 0 ;
31581 int val2 ;
31582 int ecode2 = 0 ;
31583 int val3 ;
31584 int ecode3 = 0 ;
31585 PyObject * obj0 = 0 ;
31586 PyObject * obj1 = 0 ;
31587 PyObject * obj2 = 0 ;
31588 char * kwnames[] = {
31589 (char *) "self",(char *) "width",(char *) "height", NULL
31590 };
31591
31592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31594 if (!SWIG_IsOK(res1)) {
31595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31596 }
31597 arg1 = reinterpret_cast< wxWindow * >(argp1);
31598 ecode2 = SWIG_AsVal_int(obj1, &val2);
31599 if (!SWIG_IsOK(ecode2)) {
31600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31601 }
31602 arg2 = static_cast< int >(val2);
31603 ecode3 = SWIG_AsVal_int(obj2, &val3);
31604 if (!SWIG_IsOK(ecode3)) {
31605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31606 }
31607 arg3 = static_cast< int >(val3);
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 (arg1)->SetSize(arg2,arg3);
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 resultobj = SWIG_Py_Void();
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj = 0;
31623 wxWindow *arg1 = (wxWindow *) 0 ;
31624 wxPoint *arg2 = 0 ;
31625 int arg3 = (int) wxSIZE_USE_EXISTING ;
31626 void *argp1 = 0 ;
31627 int res1 = 0 ;
31628 wxPoint temp2 ;
31629 int val3 ;
31630 int ecode3 = 0 ;
31631 PyObject * obj0 = 0 ;
31632 PyObject * obj1 = 0 ;
31633 PyObject * obj2 = 0 ;
31634 char * kwnames[] = {
31635 (char *) "self",(char *) "pt",(char *) "flags", NULL
31636 };
31637
31638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31640 if (!SWIG_IsOK(res1)) {
31641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31642 }
31643 arg1 = reinterpret_cast< wxWindow * >(argp1);
31644 {
31645 arg2 = &temp2;
31646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31647 }
31648 if (obj2) {
31649 ecode3 = SWIG_AsVal_int(obj2, &val3);
31650 if (!SWIG_IsOK(ecode3)) {
31651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31652 }
31653 arg3 = static_cast< int >(val3);
31654 }
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 (arg1)->Move((wxPoint const &)*arg2,arg3);
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 resultobj = SWIG_Py_Void();
31662 return resultobj;
31663 fail:
31664 return NULL;
31665 }
31666
31667
31668 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31669 PyObject *resultobj = 0;
31670 wxWindow *arg1 = (wxWindow *) 0 ;
31671 int arg2 ;
31672 int arg3 ;
31673 int arg4 = (int) wxSIZE_USE_EXISTING ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 int val2 ;
31677 int ecode2 = 0 ;
31678 int val3 ;
31679 int ecode3 = 0 ;
31680 int val4 ;
31681 int ecode4 = 0 ;
31682 PyObject * obj0 = 0 ;
31683 PyObject * obj1 = 0 ;
31684 PyObject * obj2 = 0 ;
31685 PyObject * obj3 = 0 ;
31686 char * kwnames[] = {
31687 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31688 };
31689
31690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31692 if (!SWIG_IsOK(res1)) {
31693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31694 }
31695 arg1 = reinterpret_cast< wxWindow * >(argp1);
31696 ecode2 = SWIG_AsVal_int(obj1, &val2);
31697 if (!SWIG_IsOK(ecode2)) {
31698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31699 }
31700 arg2 = static_cast< int >(val2);
31701 ecode3 = SWIG_AsVal_int(obj2, &val3);
31702 if (!SWIG_IsOK(ecode3)) {
31703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31704 }
31705 arg3 = static_cast< int >(val3);
31706 if (obj3) {
31707 ecode4 = SWIG_AsVal_int(obj3, &val4);
31708 if (!SWIG_IsOK(ecode4)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31710 }
31711 arg4 = static_cast< int >(val4);
31712 }
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 (arg1)->Move(arg2,arg3,arg4);
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 resultobj = SWIG_Py_Void();
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31727 PyObject *resultobj = 0;
31728 wxWindow *arg1 = (wxWindow *) 0 ;
31729 wxSize const &arg2_defvalue = wxDefaultSize ;
31730 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31731 void *argp1 = 0 ;
31732 int res1 = 0 ;
31733 wxSize temp2 ;
31734 PyObject * obj0 = 0 ;
31735 PyObject * obj1 = 0 ;
31736 char * kwnames[] = {
31737 (char *) "self",(char *) "size", NULL
31738 };
31739
31740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31744 }
31745 arg1 = reinterpret_cast< wxWindow * >(argp1);
31746 if (obj1) {
31747 {
31748 arg2 = &temp2;
31749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31750 }
31751 }
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 resultobj = SWIG_Py_Void();
31759 return resultobj;
31760 fail:
31761 return NULL;
31762 }
31763
31764
31765 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31766 PyObject *resultobj = 0;
31767 wxWindow *arg1 = (wxWindow *) 0 ;
31768 void *argp1 = 0 ;
31769 int res1 = 0 ;
31770 PyObject *swig_obj[1] ;
31771
31772 if (!args) SWIG_fail;
31773 swig_obj[0] = args;
31774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31775 if (!SWIG_IsOK(res1)) {
31776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31777 }
31778 arg1 = reinterpret_cast< wxWindow * >(argp1);
31779 {
31780 PyThreadState* __tstate = wxPyBeginAllowThreads();
31781 (arg1)->Raise();
31782 wxPyEndAllowThreads(__tstate);
31783 if (PyErr_Occurred()) SWIG_fail;
31784 }
31785 resultobj = SWIG_Py_Void();
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31793 PyObject *resultobj = 0;
31794 wxWindow *arg1 = (wxWindow *) 0 ;
31795 void *argp1 = 0 ;
31796 int res1 = 0 ;
31797 PyObject *swig_obj[1] ;
31798
31799 if (!args) SWIG_fail;
31800 swig_obj[0] = args;
31801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31802 if (!SWIG_IsOK(res1)) {
31803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31804 }
31805 arg1 = reinterpret_cast< wxWindow * >(argp1);
31806 {
31807 PyThreadState* __tstate = wxPyBeginAllowThreads();
31808 (arg1)->Lower();
31809 wxPyEndAllowThreads(__tstate);
31810 if (PyErr_Occurred()) SWIG_fail;
31811 }
31812 resultobj = SWIG_Py_Void();
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj = 0;
31821 wxWindow *arg1 = (wxWindow *) 0 ;
31822 wxSize *arg2 = 0 ;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 wxSize temp2 ;
31826 PyObject * obj0 = 0 ;
31827 PyObject * obj1 = 0 ;
31828 char * kwnames[] = {
31829 (char *) "self",(char *) "size", NULL
31830 };
31831
31832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31836 }
31837 arg1 = reinterpret_cast< wxWindow * >(argp1);
31838 {
31839 arg2 = &temp2;
31840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31841 }
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 (arg1)->SetClientSize((wxSize const &)*arg2);
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_Py_Void();
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj = 0;
31857 wxWindow *arg1 = (wxWindow *) 0 ;
31858 int arg2 ;
31859 int arg3 ;
31860 void *argp1 = 0 ;
31861 int res1 = 0 ;
31862 int val2 ;
31863 int ecode2 = 0 ;
31864 int val3 ;
31865 int ecode3 = 0 ;
31866 PyObject * obj0 = 0 ;
31867 PyObject * obj1 = 0 ;
31868 PyObject * obj2 = 0 ;
31869 char * kwnames[] = {
31870 (char *) "self",(char *) "width",(char *) "height", NULL
31871 };
31872
31873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31875 if (!SWIG_IsOK(res1)) {
31876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31877 }
31878 arg1 = reinterpret_cast< wxWindow * >(argp1);
31879 ecode2 = SWIG_AsVal_int(obj1, &val2);
31880 if (!SWIG_IsOK(ecode2)) {
31881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31882 }
31883 arg2 = static_cast< int >(val2);
31884 ecode3 = SWIG_AsVal_int(obj2, &val3);
31885 if (!SWIG_IsOK(ecode3)) {
31886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31887 }
31888 arg3 = static_cast< int >(val3);
31889 {
31890 PyThreadState* __tstate = wxPyBeginAllowThreads();
31891 (arg1)->SetClientSize(arg2,arg3);
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 resultobj = SWIG_Py_Void();
31896 return resultobj;
31897 fail:
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31903 PyObject *resultobj = 0;
31904 wxWindow *arg1 = (wxWindow *) 0 ;
31905 wxRect *arg2 = 0 ;
31906 void *argp1 = 0 ;
31907 int res1 = 0 ;
31908 wxRect temp2 ;
31909 PyObject * obj0 = 0 ;
31910 PyObject * obj1 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "self",(char *) "rect", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31919 }
31920 arg1 = reinterpret_cast< wxWindow * >(argp1);
31921 {
31922 arg2 = &temp2;
31923 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31924 }
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 (arg1)->SetClientSize((wxRect const &)*arg2);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_Py_Void();
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 wxPoint result;
31942 void *argp1 = 0 ;
31943 int res1 = 0 ;
31944 PyObject *swig_obj[1] ;
31945
31946 if (!args) SWIG_fail;
31947 swig_obj[0] = args;
31948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31951 }
31952 arg1 = reinterpret_cast< wxWindow * >(argp1);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = ((wxWindow const *)arg1)->GetPosition();
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 int *arg2 = (int *) 0 ;
31970 int *arg3 = (int *) 0 ;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 int temp2 ;
31974 int res2 = SWIG_TMPOBJ ;
31975 int temp3 ;
31976 int res3 = SWIG_TMPOBJ ;
31977 PyObject *swig_obj[1] ;
31978
31979 arg2 = &temp2;
31980 arg3 = &temp3;
31981 if (!args) SWIG_fail;
31982 swig_obj[0] = args;
31983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 PyThreadState* __tstate = wxPyBeginAllowThreads();
31990 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_Py_Void();
31995 if (SWIG_IsTmpObj(res2)) {
31996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31997 } else {
31998 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32000 }
32001 if (SWIG_IsTmpObj(res3)) {
32002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32003 } else {
32004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32006 }
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32014 PyObject *resultobj = 0;
32015 wxWindow *arg1 = (wxWindow *) 0 ;
32016 wxPoint result;
32017 void *argp1 = 0 ;
32018 int res1 = 0 ;
32019 PyObject *swig_obj[1] ;
32020
32021 if (!args) SWIG_fail;
32022 swig_obj[0] = args;
32023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32026 }
32027 arg1 = reinterpret_cast< wxWindow * >(argp1);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 result = ((wxWindow const *)arg1)->GetScreenPosition();
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 PyObject *resultobj = 0;
32043 wxWindow *arg1 = (wxWindow *) 0 ;
32044 int *arg2 = (int *) 0 ;
32045 int *arg3 = (int *) 0 ;
32046 void *argp1 = 0 ;
32047 int res1 = 0 ;
32048 int temp2 ;
32049 int res2 = SWIG_TMPOBJ ;
32050 int temp3 ;
32051 int res3 = SWIG_TMPOBJ ;
32052 PyObject *swig_obj[1] ;
32053
32054 arg2 = &temp2;
32055 arg3 = &temp3;
32056 if (!args) SWIG_fail;
32057 swig_obj[0] = args;
32058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32059 if (!SWIG_IsOK(res1)) {
32060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32061 }
32062 arg1 = reinterpret_cast< wxWindow * >(argp1);
32063 {
32064 PyThreadState* __tstate = wxPyBeginAllowThreads();
32065 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32066 wxPyEndAllowThreads(__tstate);
32067 if (PyErr_Occurred()) SWIG_fail;
32068 }
32069 resultobj = SWIG_Py_Void();
32070 if (SWIG_IsTmpObj(res2)) {
32071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32072 } else {
32073 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32075 }
32076 if (SWIG_IsTmpObj(res3)) {
32077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32078 } else {
32079 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32081 }
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxWindow *arg1 = (wxWindow *) 0 ;
32091 wxRect result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 PyObject *swig_obj[1] ;
32095
32096 if (!args) SWIG_fail;
32097 swig_obj[0] = args;
32098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32101 }
32102 arg1 = reinterpret_cast< wxWindow * >(argp1);
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 result = ((wxWindow const *)arg1)->GetScreenRect();
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxWindow *arg1 = (wxWindow *) 0 ;
32119 wxSize result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = ((wxWindow const *)arg1)->GetSize();
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 int *arg2 = (int *) 0 ;
32148 int *arg3 = (int *) 0 ;
32149 void *argp1 = 0 ;
32150 int res1 = 0 ;
32151 int temp2 ;
32152 int res2 = SWIG_TMPOBJ ;
32153 int temp3 ;
32154 int res3 = SWIG_TMPOBJ ;
32155 PyObject *swig_obj[1] ;
32156
32157 arg2 = &temp2;
32158 arg3 = &temp3;
32159 if (!args) SWIG_fail;
32160 swig_obj[0] = args;
32161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32162 if (!SWIG_IsOK(res1)) {
32163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32164 }
32165 arg1 = reinterpret_cast< wxWindow * >(argp1);
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 resultobj = SWIG_Py_Void();
32173 if (SWIG_IsTmpObj(res2)) {
32174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32175 } else {
32176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32178 }
32179 if (SWIG_IsTmpObj(res3)) {
32180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32181 } else {
32182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32184 }
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 wxRect result;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 PyObject *swig_obj[1] ;
32198
32199 if (!args) SWIG_fail;
32200 swig_obj[0] = args;
32201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32204 }
32205 arg1 = reinterpret_cast< wxWindow * >(argp1);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 result = ((wxWindow const *)arg1)->GetRect();
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 wxSize result;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 PyObject *swig_obj[1] ;
32226
32227 if (!args) SWIG_fail;
32228 swig_obj[0] = args;
32229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32230 if (!SWIG_IsOK(res1)) {
32231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32232 }
32233 arg1 = reinterpret_cast< wxWindow * >(argp1);
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 result = ((wxWindow const *)arg1)->GetClientSize();
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32248 PyObject *resultobj = 0;
32249 wxWindow *arg1 = (wxWindow *) 0 ;
32250 int *arg2 = (int *) 0 ;
32251 int *arg3 = (int *) 0 ;
32252 void *argp1 = 0 ;
32253 int res1 = 0 ;
32254 int temp2 ;
32255 int res2 = SWIG_TMPOBJ ;
32256 int temp3 ;
32257 int res3 = SWIG_TMPOBJ ;
32258 PyObject *swig_obj[1] ;
32259
32260 arg2 = &temp2;
32261 arg3 = &temp3;
32262 if (!args) SWIG_fail;
32263 swig_obj[0] = args;
32264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32265 if (!SWIG_IsOK(res1)) {
32266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32267 }
32268 arg1 = reinterpret_cast< wxWindow * >(argp1);
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 resultobj = SWIG_Py_Void();
32276 if (SWIG_IsTmpObj(res2)) {
32277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32278 } else {
32279 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32281 }
32282 if (SWIG_IsTmpObj(res3)) {
32283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32284 } else {
32285 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxWindow *arg1 = (wxWindow *) 0 ;
32297 wxPoint result;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32307 }
32308 arg1 = reinterpret_cast< wxWindow * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 wxRect result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = ((wxWindow const *)arg1)->GetClientRect();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *resultobj = 0;
32352 wxWindow *arg1 = (wxWindow *) 0 ;
32353 wxSize result;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 PyObject *swig_obj[1] ;
32357
32358 if (!args) SWIG_fail;
32359 swig_obj[0] = args;
32360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32361 if (!SWIG_IsOK(res1)) {
32362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32363 }
32364 arg1 = reinterpret_cast< wxWindow * >(argp1);
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 result = ((wxWindow const *)arg1)->GetBestSize();
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32379 PyObject *resultobj = 0;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 int *arg2 = (int *) 0 ;
32382 int *arg3 = (int *) 0 ;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 int temp2 ;
32386 int res2 = SWIG_TMPOBJ ;
32387 int temp3 ;
32388 int res3 = SWIG_TMPOBJ ;
32389 PyObject *swig_obj[1] ;
32390
32391 arg2 = &temp2;
32392 arg3 = &temp3;
32393 if (!args) SWIG_fail;
32394 swig_obj[0] = args;
32395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32396 if (!SWIG_IsOK(res1)) {
32397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32398 }
32399 arg1 = reinterpret_cast< wxWindow * >(argp1);
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_Py_Void();
32407 if (SWIG_IsTmpObj(res2)) {
32408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32409 } else {
32410 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32412 }
32413 if (SWIG_IsTmpObj(res3)) {
32414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32415 } else {
32416 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32437 }
32438 arg1 = reinterpret_cast< wxWindow * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 (arg1)->InvalidateBestSize();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 resultobj = SWIG_Py_Void();
32446 return resultobj;
32447 fail:
32448 return NULL;
32449 }
32450
32451
32452 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32453 PyObject *resultobj = 0;
32454 wxWindow *arg1 = (wxWindow *) 0 ;
32455 wxSize *arg2 = 0 ;
32456 void *argp1 = 0 ;
32457 int res1 = 0 ;
32458 wxSize temp2 ;
32459 PyObject * obj0 = 0 ;
32460 PyObject * obj1 = 0 ;
32461 char * kwnames[] = {
32462 (char *) "self",(char *) "size", NULL
32463 };
32464
32465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32467 if (!SWIG_IsOK(res1)) {
32468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32469 }
32470 arg1 = reinterpret_cast< wxWindow * >(argp1);
32471 {
32472 arg2 = &temp2;
32473 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32474 }
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 resultobj = SWIG_Py_Void();
32482 return resultobj;
32483 fail:
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32489 PyObject *resultobj = 0;
32490 wxWindow *arg1 = (wxWindow *) 0 ;
32491 wxSize result;
32492 void *argp1 = 0 ;
32493 int res1 = 0 ;
32494 PyObject *swig_obj[1] ;
32495
32496 if (!args) SWIG_fail;
32497 swig_obj[0] = args;
32498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32499 if (!SWIG_IsOK(res1)) {
32500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32501 }
32502 arg1 = reinterpret_cast< wxWindow * >(argp1);
32503 {
32504 PyThreadState* __tstate = wxPyBeginAllowThreads();
32505 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxWindow *arg1 = (wxWindow *) 0 ;
32519 wxSize result;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 PyObject *swig_obj[1] ;
32523
32524 if (!args) SWIG_fail;
32525 swig_obj[0] = args;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32529 }
32530 arg1 = reinterpret_cast< wxWindow * >(argp1);
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = 0;
32546 wxWindow *arg1 = (wxWindow *) 0 ;
32547 int arg2 = (int) wxBOTH ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 int val2 ;
32551 int ecode2 = 0 ;
32552 PyObject * obj0 = 0 ;
32553 PyObject * obj1 = 0 ;
32554 char * kwnames[] = {
32555 (char *) "self",(char *) "direction", NULL
32556 };
32557
32558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32562 }
32563 arg1 = reinterpret_cast< wxWindow * >(argp1);
32564 if (obj1) {
32565 ecode2 = SWIG_AsVal_int(obj1, &val2);
32566 if (!SWIG_IsOK(ecode2)) {
32567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32568 }
32569 arg2 = static_cast< int >(val2);
32570 }
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->Center(arg2);
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj = 0;
32586 wxWindow *arg1 = (wxWindow *) 0 ;
32587 int arg2 = (int) wxBOTH ;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 int val2 ;
32591 int ecode2 = 0 ;
32592 PyObject * obj0 = 0 ;
32593 PyObject * obj1 = 0 ;
32594 char * kwnames[] = {
32595 (char *) "self",(char *) "dir", NULL
32596 };
32597
32598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32602 }
32603 arg1 = reinterpret_cast< wxWindow * >(argp1);
32604 if (obj1) {
32605 ecode2 = SWIG_AsVal_int(obj1, &val2);
32606 if (!SWIG_IsOK(ecode2)) {
32607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32608 }
32609 arg2 = static_cast< int >(val2);
32610 }
32611 {
32612 PyThreadState* __tstate = wxPyBeginAllowThreads();
32613 (arg1)->CenterOnParent(arg2);
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 resultobj = SWIG_Py_Void();
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32625 PyObject *resultobj = 0;
32626 wxWindow *arg1 = (wxWindow *) 0 ;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 PyObject *swig_obj[1] ;
32630
32631 if (!args) SWIG_fail;
32632 swig_obj[0] = args;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32636 }
32637 arg1 = reinterpret_cast< wxWindow * >(argp1);
32638 {
32639 PyThreadState* __tstate = wxPyBeginAllowThreads();
32640 (arg1)->Fit();
32641 wxPyEndAllowThreads(__tstate);
32642 if (PyErr_Occurred()) SWIG_fail;
32643 }
32644 resultobj = SWIG_Py_Void();
32645 return resultobj;
32646 fail:
32647 return NULL;
32648 }
32649
32650
32651 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 PyObject *resultobj = 0;
32653 wxWindow *arg1 = (wxWindow *) 0 ;
32654 void *argp1 = 0 ;
32655 int res1 = 0 ;
32656 PyObject *swig_obj[1] ;
32657
32658 if (!args) SWIG_fail;
32659 swig_obj[0] = args;
32660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32661 if (!SWIG_IsOK(res1)) {
32662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32663 }
32664 arg1 = reinterpret_cast< wxWindow * >(argp1);
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 (arg1)->FitInside();
32668 wxPyEndAllowThreads(__tstate);
32669 if (PyErr_Occurred()) SWIG_fail;
32670 }
32671 resultobj = SWIG_Py_Void();
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32679 PyObject *resultobj = 0;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 int arg2 ;
32682 int arg3 ;
32683 int arg4 = (int) -1 ;
32684 int arg5 = (int) -1 ;
32685 int arg6 = (int) -1 ;
32686 int arg7 = (int) -1 ;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 int val2 ;
32690 int ecode2 = 0 ;
32691 int val3 ;
32692 int ecode3 = 0 ;
32693 int val4 ;
32694 int ecode4 = 0 ;
32695 int val5 ;
32696 int ecode5 = 0 ;
32697 int val6 ;
32698 int ecode6 = 0 ;
32699 int val7 ;
32700 int ecode7 = 0 ;
32701 PyObject * obj0 = 0 ;
32702 PyObject * obj1 = 0 ;
32703 PyObject * obj2 = 0 ;
32704 PyObject * obj3 = 0 ;
32705 PyObject * obj4 = 0 ;
32706 PyObject * obj5 = 0 ;
32707 PyObject * obj6 = 0 ;
32708 char * kwnames[] = {
32709 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32710 };
32711
32712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32716 }
32717 arg1 = reinterpret_cast< wxWindow * >(argp1);
32718 ecode2 = SWIG_AsVal_int(obj1, &val2);
32719 if (!SWIG_IsOK(ecode2)) {
32720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32721 }
32722 arg2 = static_cast< int >(val2);
32723 ecode3 = SWIG_AsVal_int(obj2, &val3);
32724 if (!SWIG_IsOK(ecode3)) {
32725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32726 }
32727 arg3 = static_cast< int >(val3);
32728 if (obj3) {
32729 ecode4 = SWIG_AsVal_int(obj3, &val4);
32730 if (!SWIG_IsOK(ecode4)) {
32731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32732 }
32733 arg4 = static_cast< int >(val4);
32734 }
32735 if (obj4) {
32736 ecode5 = SWIG_AsVal_int(obj4, &val5);
32737 if (!SWIG_IsOK(ecode5)) {
32738 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32739 }
32740 arg5 = static_cast< int >(val5);
32741 }
32742 if (obj5) {
32743 ecode6 = SWIG_AsVal_int(obj5, &val6);
32744 if (!SWIG_IsOK(ecode6)) {
32745 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32746 }
32747 arg6 = static_cast< int >(val6);
32748 }
32749 if (obj6) {
32750 ecode7 = SWIG_AsVal_int(obj6, &val7);
32751 if (!SWIG_IsOK(ecode7)) {
32752 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32753 }
32754 arg7 = static_cast< int >(val7);
32755 }
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 resultobj = SWIG_Py_Void();
32763 return resultobj;
32764 fail:
32765 return NULL;
32766 }
32767
32768
32769 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32770 PyObject *resultobj = 0;
32771 wxWindow *arg1 = (wxWindow *) 0 ;
32772 wxSize *arg2 = 0 ;
32773 wxSize const &arg3_defvalue = wxDefaultSize ;
32774 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32775 wxSize const &arg4_defvalue = wxDefaultSize ;
32776 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32777 void *argp1 = 0 ;
32778 int res1 = 0 ;
32779 wxSize temp2 ;
32780 wxSize temp3 ;
32781 wxSize temp4 ;
32782 PyObject * obj0 = 0 ;
32783 PyObject * obj1 = 0 ;
32784 PyObject * obj2 = 0 ;
32785 PyObject * obj3 = 0 ;
32786 char * kwnames[] = {
32787 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32788 };
32789
32790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32792 if (!SWIG_IsOK(res1)) {
32793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32794 }
32795 arg1 = reinterpret_cast< wxWindow * >(argp1);
32796 {
32797 arg2 = &temp2;
32798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32799 }
32800 if (obj2) {
32801 {
32802 arg3 = &temp3;
32803 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32804 }
32805 }
32806 if (obj3) {
32807 {
32808 arg4 = &temp4;
32809 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32810 }
32811 }
32812 {
32813 PyThreadState* __tstate = wxPyBeginAllowThreads();
32814 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32815 wxPyEndAllowThreads(__tstate);
32816 if (PyErr_Occurred()) SWIG_fail;
32817 }
32818 resultobj = SWIG_Py_Void();
32819 return resultobj;
32820 fail:
32821 return NULL;
32822 }
32823
32824
32825 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32826 PyObject *resultobj = 0;
32827 wxWindow *arg1 = (wxWindow *) 0 ;
32828 int arg2 ;
32829 int arg3 ;
32830 int arg4 = (int) -1 ;
32831 int arg5 = (int) -1 ;
32832 void *argp1 = 0 ;
32833 int res1 = 0 ;
32834 int val2 ;
32835 int ecode2 = 0 ;
32836 int val3 ;
32837 int ecode3 = 0 ;
32838 int val4 ;
32839 int ecode4 = 0 ;
32840 int val5 ;
32841 int ecode5 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 PyObject * obj2 = 0 ;
32845 PyObject * obj3 = 0 ;
32846 PyObject * obj4 = 0 ;
32847 char * kwnames[] = {
32848 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32849 };
32850
32851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res1)) {
32854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32855 }
32856 arg1 = reinterpret_cast< wxWindow * >(argp1);
32857 ecode2 = SWIG_AsVal_int(obj1, &val2);
32858 if (!SWIG_IsOK(ecode2)) {
32859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32860 }
32861 arg2 = static_cast< int >(val2);
32862 ecode3 = SWIG_AsVal_int(obj2, &val3);
32863 if (!SWIG_IsOK(ecode3)) {
32864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32865 }
32866 arg3 = static_cast< int >(val3);
32867 if (obj3) {
32868 ecode4 = SWIG_AsVal_int(obj3, &val4);
32869 if (!SWIG_IsOK(ecode4)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32871 }
32872 arg4 = static_cast< int >(val4);
32873 }
32874 if (obj4) {
32875 ecode5 = SWIG_AsVal_int(obj4, &val5);
32876 if (!SWIG_IsOK(ecode5)) {
32877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32878 }
32879 arg5 = static_cast< int >(val5);
32880 }
32881 {
32882 PyThreadState* __tstate = wxPyBeginAllowThreads();
32883 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32884 wxPyEndAllowThreads(__tstate);
32885 if (PyErr_Occurred()) SWIG_fail;
32886 }
32887 resultobj = SWIG_Py_Void();
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32895 PyObject *resultobj = 0;
32896 wxWindow *arg1 = (wxWindow *) 0 ;
32897 wxSize *arg2 = 0 ;
32898 wxSize const &arg3_defvalue = wxDefaultSize ;
32899 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32900 void *argp1 = 0 ;
32901 int res1 = 0 ;
32902 wxSize temp2 ;
32903 wxSize temp3 ;
32904 PyObject * obj0 = 0 ;
32905 PyObject * obj1 = 0 ;
32906 PyObject * obj2 = 0 ;
32907 char * kwnames[] = {
32908 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32909 };
32910
32911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32913 if (!SWIG_IsOK(res1)) {
32914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32915 }
32916 arg1 = reinterpret_cast< wxWindow * >(argp1);
32917 {
32918 arg2 = &temp2;
32919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32920 }
32921 if (obj2) {
32922 {
32923 arg3 = &temp3;
32924 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32925 }
32926 }
32927 {
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 resultobj = SWIG_Py_Void();
32934 return resultobj;
32935 fail:
32936 return NULL;
32937 }
32938
32939
32940 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32941 PyObject *resultobj = 0;
32942 wxWindow *arg1 = (wxWindow *) 0 ;
32943 wxSize result;
32944 void *argp1 = 0 ;
32945 int res1 = 0 ;
32946 PyObject *swig_obj[1] ;
32947
32948 if (!args) SWIG_fail;
32949 swig_obj[0] = args;
32950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32951 if (!SWIG_IsOK(res1)) {
32952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32953 }
32954 arg1 = reinterpret_cast< wxWindow * >(argp1);
32955 {
32956 PyThreadState* __tstate = wxPyBeginAllowThreads();
32957 result = ((wxWindow const *)arg1)->GetMaxSize();
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32962 return resultobj;
32963 fail:
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32969 PyObject *resultobj = 0;
32970 wxWindow *arg1 = (wxWindow *) 0 ;
32971 wxSize result;
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_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32981 }
32982 arg1 = reinterpret_cast< wxWindow * >(argp1);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 result = ((wxWindow const *)arg1)->GetMinSize();
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 wxSize *arg2 = 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 wxSize temp2 ;
33003 PyObject * obj0 = 0 ;
33004 PyObject * obj1 = 0 ;
33005 char * kwnames[] = {
33006 (char *) "self",(char *) "minSize", NULL
33007 };
33008
33009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33013 }
33014 arg1 = reinterpret_cast< wxWindow * >(argp1);
33015 {
33016 arg2 = &temp2;
33017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33018 }
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 (arg1)->SetMinSize((wxSize const &)*arg2);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_Py_Void();
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33033 PyObject *resultobj = 0;
33034 wxWindow *arg1 = (wxWindow *) 0 ;
33035 wxSize *arg2 = 0 ;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 wxSize temp2 ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "maxSize", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 arg2 = &temp2;
33053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->SetMaxSize((wxSize const &)*arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 int result;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 PyObject *swig_obj[1] ;
33075
33076 if (!args) SWIG_fail;
33077 swig_obj[0] = args;
33078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_From_int(static_cast< int >(result));
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxWindow *arg1 = (wxWindow *) 0 ;
33099 int result;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 resultobj = SWIG_From_int(static_cast< int >(result));
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33125 PyObject *resultobj = 0;
33126 wxWindow *arg1 = (wxWindow *) 0 ;
33127 int result;
33128 void *argp1 = 0 ;
33129 int res1 = 0 ;
33130 PyObject *swig_obj[1] ;
33131
33132 if (!args) SWIG_fail;
33133 swig_obj[0] = args;
33134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33135 if (!SWIG_IsOK(res1)) {
33136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33137 }
33138 arg1 = reinterpret_cast< wxWindow * >(argp1);
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 resultobj = SWIG_From_int(static_cast< int >(result));
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 int result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject *swig_obj[1] ;
33159
33160 if (!args) SWIG_fail;
33161 swig_obj[0] = args;
33162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 resultobj = SWIG_From_int(static_cast< int >(result));
33174 return resultobj;
33175 fail:
33176 return NULL;
33177 }
33178
33179
33180 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33181 PyObject *resultobj = 0;
33182 wxWindow *arg1 = (wxWindow *) 0 ;
33183 wxSize *arg2 = 0 ;
33184 void *argp1 = 0 ;
33185 int res1 = 0 ;
33186 wxSize temp2 ;
33187 PyObject * obj0 = 0 ;
33188 PyObject * obj1 = 0 ;
33189 char * kwnames[] = {
33190 (char *) "self",(char *) "size", NULL
33191 };
33192
33193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33197 }
33198 arg1 = reinterpret_cast< wxWindow * >(argp1);
33199 {
33200 arg2 = &temp2;
33201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33202 }
33203 {
33204 PyThreadState* __tstate = wxPyBeginAllowThreads();
33205 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33206 wxPyEndAllowThreads(__tstate);
33207 if (PyErr_Occurred()) SWIG_fail;
33208 }
33209 resultobj = SWIG_Py_Void();
33210 return resultobj;
33211 fail:
33212 return NULL;
33213 }
33214
33215
33216 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33217 PyObject *resultobj = 0;
33218 wxWindow *arg1 = (wxWindow *) 0 ;
33219 int arg2 ;
33220 int arg3 ;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 int val2 ;
33224 int ecode2 = 0 ;
33225 int val3 ;
33226 int ecode3 = 0 ;
33227 PyObject * obj0 = 0 ;
33228 PyObject * obj1 = 0 ;
33229 PyObject * obj2 = 0 ;
33230 char * kwnames[] = {
33231 (char *) "self",(char *) "w",(char *) "h", NULL
33232 };
33233
33234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33236 if (!SWIG_IsOK(res1)) {
33237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33238 }
33239 arg1 = reinterpret_cast< wxWindow * >(argp1);
33240 ecode2 = SWIG_AsVal_int(obj1, &val2);
33241 if (!SWIG_IsOK(ecode2)) {
33242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33243 }
33244 arg2 = static_cast< int >(val2);
33245 ecode3 = SWIG_AsVal_int(obj2, &val3);
33246 if (!SWIG_IsOK(ecode3)) {
33247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33248 }
33249 arg3 = static_cast< int >(val3);
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 (arg1)->SetVirtualSize(arg2,arg3);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 resultobj = SWIG_Py_Void();
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33264 PyObject *resultobj = 0;
33265 wxWindow *arg1 = (wxWindow *) 0 ;
33266 wxSize result;
33267 void *argp1 = 0 ;
33268 int res1 = 0 ;
33269 PyObject *swig_obj[1] ;
33270
33271 if (!args) SWIG_fail;
33272 swig_obj[0] = args;
33273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33274 if (!SWIG_IsOK(res1)) {
33275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33276 }
33277 arg1 = reinterpret_cast< wxWindow * >(argp1);
33278 {
33279 PyThreadState* __tstate = wxPyBeginAllowThreads();
33280 result = ((wxWindow const *)arg1)->GetVirtualSize();
33281 wxPyEndAllowThreads(__tstate);
33282 if (PyErr_Occurred()) SWIG_fail;
33283 }
33284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 int *arg2 = (int *) 0 ;
33295 int *arg3 = (int *) 0 ;
33296 void *argp1 = 0 ;
33297 int res1 = 0 ;
33298 int temp2 ;
33299 int res2 = SWIG_TMPOBJ ;
33300 int temp3 ;
33301 int res3 = SWIG_TMPOBJ ;
33302 PyObject *swig_obj[1] ;
33303
33304 arg2 = &temp2;
33305 arg3 = &temp3;
33306 if (!args) SWIG_fail;
33307 swig_obj[0] = args;
33308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33309 if (!SWIG_IsOK(res1)) {
33310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33311 }
33312 arg1 = reinterpret_cast< wxWindow * >(argp1);
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 resultobj = SWIG_Py_Void();
33320 if (SWIG_IsTmpObj(res2)) {
33321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33322 } else {
33323 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33325 }
33326 if (SWIG_IsTmpObj(res3)) {
33327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33328 } else {
33329 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33331 }
33332 return resultobj;
33333 fail:
33334 return NULL;
33335 }
33336
33337
33338 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33339 PyObject *resultobj = 0;
33340 wxWindow *arg1 = (wxWindow *) 0 ;
33341 wxSize result;
33342 void *argp1 = 0 ;
33343 int res1 = 0 ;
33344 PyObject *swig_obj[1] ;
33345
33346 if (!args) SWIG_fail;
33347 swig_obj[0] = args;
33348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33349 if (!SWIG_IsOK(res1)) {
33350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33351 }
33352 arg1 = reinterpret_cast< wxWindow * >(argp1);
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33356 wxPyEndAllowThreads(__tstate);
33357 if (PyErr_Occurred()) SWIG_fail;
33358 }
33359 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj = 0;
33368 wxWindow *arg1 = (wxWindow *) 0 ;
33369 bool arg2 = (bool) true ;
33370 bool result;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 bool val2 ;
33374 int ecode2 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "self",(char *) "show", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 if (obj1) {
33388 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33389 if (!SWIG_IsOK(ecode2)) {
33390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33391 }
33392 arg2 = static_cast< bool >(val2);
33393 }
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 result = (bool)(arg1)->Show(arg2);
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 {
33401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33402 }
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33410 PyObject *resultobj = 0;
33411 wxWindow *arg1 = (wxWindow *) 0 ;
33412 bool result;
33413 void *argp1 = 0 ;
33414 int res1 = 0 ;
33415 PyObject *swig_obj[1] ;
33416
33417 if (!args) SWIG_fail;
33418 swig_obj[0] = args;
33419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33420 if (!SWIG_IsOK(res1)) {
33421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33422 }
33423 arg1 = reinterpret_cast< wxWindow * >(argp1);
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = (bool)(arg1)->Hide();
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 {
33431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33432 }
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 bool arg2 = (bool) true ;
33443 bool result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 bool val2 ;
33447 int ecode2 = 0 ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 char * kwnames[] = {
33451 (char *) "self",(char *) "enable", NULL
33452 };
33453
33454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33456 if (!SWIG_IsOK(res1)) {
33457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33458 }
33459 arg1 = reinterpret_cast< wxWindow * >(argp1);
33460 if (obj1) {
33461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33462 if (!SWIG_IsOK(ecode2)) {
33463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33464 }
33465 arg2 = static_cast< bool >(val2);
33466 }
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 result = (bool)(arg1)->Enable(arg2);
33470 wxPyEndAllowThreads(__tstate);
33471 if (PyErr_Occurred()) SWIG_fail;
33472 }
33473 {
33474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33475 }
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33483 PyObject *resultobj = 0;
33484 wxWindow *arg1 = (wxWindow *) 0 ;
33485 bool result;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 PyObject *swig_obj[1] ;
33489
33490 if (!args) SWIG_fail;
33491 swig_obj[0] = args;
33492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33495 }
33496 arg1 = reinterpret_cast< wxWindow * >(argp1);
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 result = (bool)(arg1)->Disable();
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 {
33504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33505 }
33506 return resultobj;
33507 fail:
33508 return NULL;
33509 }
33510
33511
33512 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33513 PyObject *resultobj = 0;
33514 wxWindow *arg1 = (wxWindow *) 0 ;
33515 bool result;
33516 void *argp1 = 0 ;
33517 int res1 = 0 ;
33518 PyObject *swig_obj[1] ;
33519
33520 if (!args) SWIG_fail;
33521 swig_obj[0] = args;
33522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33523 if (!SWIG_IsOK(res1)) {
33524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33525 }
33526 arg1 = reinterpret_cast< wxWindow * >(argp1);
33527 {
33528 PyThreadState* __tstate = wxPyBeginAllowThreads();
33529 result = (bool)((wxWindow const *)arg1)->IsShown();
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 {
33534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33535 }
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33543 PyObject *resultobj = 0;
33544 wxWindow *arg1 = (wxWindow *) 0 ;
33545 bool result;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 PyObject *swig_obj[1] ;
33549
33550 if (!args) SWIG_fail;
33551 swig_obj[0] = args;
33552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33555 }
33556 arg1 = reinterpret_cast< wxWindow * >(argp1);
33557 {
33558 PyThreadState* __tstate = wxPyBeginAllowThreads();
33559 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33560 wxPyEndAllowThreads(__tstate);
33561 if (PyErr_Occurred()) SWIG_fail;
33562 }
33563 {
33564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33565 }
33566 return resultobj;
33567 fail:
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33573 PyObject *resultobj = 0;
33574 wxWindow *arg1 = (wxWindow *) 0 ;
33575 bool result;
33576 void *argp1 = 0 ;
33577 int res1 = 0 ;
33578 PyObject *swig_obj[1] ;
33579
33580 if (!args) SWIG_fail;
33581 swig_obj[0] = args;
33582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33583 if (!SWIG_IsOK(res1)) {
33584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33585 }
33586 arg1 = reinterpret_cast< wxWindow * >(argp1);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33595 }
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33603 PyObject *resultobj = 0;
33604 wxWindow *arg1 = (wxWindow *) 0 ;
33605 long arg2 ;
33606 void *argp1 = 0 ;
33607 int res1 = 0 ;
33608 long val2 ;
33609 int ecode2 = 0 ;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char * kwnames[] = {
33613 (char *) "self",(char *) "style", NULL
33614 };
33615
33616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33618 if (!SWIG_IsOK(res1)) {
33619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33620 }
33621 arg1 = reinterpret_cast< wxWindow * >(argp1);
33622 ecode2 = SWIG_AsVal_long(obj1, &val2);
33623 if (!SWIG_IsOK(ecode2)) {
33624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33625 }
33626 arg2 = static_cast< long >(val2);
33627 {
33628 PyThreadState* __tstate = wxPyBeginAllowThreads();
33629 (arg1)->SetWindowStyleFlag(arg2);
33630 wxPyEndAllowThreads(__tstate);
33631 if (PyErr_Occurred()) SWIG_fail;
33632 }
33633 resultobj = SWIG_Py_Void();
33634 return resultobj;
33635 fail:
33636 return NULL;
33637 }
33638
33639
33640 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 PyObject *resultobj = 0;
33642 wxWindow *arg1 = (wxWindow *) 0 ;
33643 long result;
33644 void *argp1 = 0 ;
33645 int res1 = 0 ;
33646 PyObject *swig_obj[1] ;
33647
33648 if (!args) SWIG_fail;
33649 swig_obj[0] = args;
33650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33651 if (!SWIG_IsOK(res1)) {
33652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33653 }
33654 arg1 = reinterpret_cast< wxWindow * >(argp1);
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_From_long(static_cast< long >(result));
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 int arg2 ;
33672 bool result;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 int val2 ;
33676 int ecode2 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 char * kwnames[] = {
33680 (char *) "self",(char *) "flag", NULL
33681 };
33682
33683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33685 if (!SWIG_IsOK(res1)) {
33686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33687 }
33688 arg1 = reinterpret_cast< wxWindow * >(argp1);
33689 ecode2 = SWIG_AsVal_int(obj1, &val2);
33690 if (!SWIG_IsOK(ecode2)) {
33691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33692 }
33693 arg2 = static_cast< int >(val2);
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33697 wxPyEndAllowThreads(__tstate);
33698 if (PyErr_Occurred()) SWIG_fail;
33699 }
33700 {
33701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33702 }
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33710 PyObject *resultobj = 0;
33711 wxWindow *arg1 = (wxWindow *) 0 ;
33712 bool result;
33713 void *argp1 = 0 ;
33714 int res1 = 0 ;
33715 PyObject *swig_obj[1] ;
33716
33717 if (!args) SWIG_fail;
33718 swig_obj[0] = args;
33719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33720 if (!SWIG_IsOK(res1)) {
33721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33722 }
33723 arg1 = reinterpret_cast< wxWindow * >(argp1);
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (bool)((wxWindow const *)arg1)->IsRetained();
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 {
33731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33732 }
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 long arg2 ;
33743 void *argp1 = 0 ;
33744 int res1 = 0 ;
33745 long val2 ;
33746 int ecode2 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "exStyle", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_long(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33762 }
33763 arg2 = static_cast< long >(val2);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 (arg1)->SetExtraStyle(arg2);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 resultobj = SWIG_Py_Void();
33771 return resultobj;
33772 fail:
33773 return NULL;
33774 }
33775
33776
33777 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33778 PyObject *resultobj = 0;
33779 wxWindow *arg1 = (wxWindow *) 0 ;
33780 long result;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 PyObject *swig_obj[1] ;
33784
33785 if (!args) SWIG_fail;
33786 swig_obj[0] = args;
33787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33788 if (!SWIG_IsOK(res1)) {
33789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33790 }
33791 arg1 = reinterpret_cast< wxWindow * >(argp1);
33792 {
33793 PyThreadState* __tstate = wxPyBeginAllowThreads();
33794 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 resultobj = SWIG_From_long(static_cast< long >(result));
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj = 0;
33807 wxWindow *arg1 = (wxWindow *) 0 ;
33808 bool arg2 = (bool) true ;
33809 void *argp1 = 0 ;
33810 int res1 = 0 ;
33811 bool val2 ;
33812 int ecode2 = 0 ;
33813 PyObject * obj0 = 0 ;
33814 PyObject * obj1 = 0 ;
33815 char * kwnames[] = {
33816 (char *) "self",(char *) "modal", NULL
33817 };
33818
33819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33821 if (!SWIG_IsOK(res1)) {
33822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33823 }
33824 arg1 = reinterpret_cast< wxWindow * >(argp1);
33825 if (obj1) {
33826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33827 if (!SWIG_IsOK(ecode2)) {
33828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33829 }
33830 arg2 = static_cast< bool >(val2);
33831 }
33832 {
33833 PyThreadState* __tstate = wxPyBeginAllowThreads();
33834 (arg1)->MakeModal(arg2);
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 resultobj = SWIG_Py_Void();
33839 return resultobj;
33840 fail:
33841 return NULL;
33842 }
33843
33844
33845 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33846 PyObject *resultobj = 0;
33847 wxWindow *arg1 = (wxWindow *) 0 ;
33848 bool arg2 ;
33849 void *argp1 = 0 ;
33850 int res1 = 0 ;
33851 bool val2 ;
33852 int ecode2 = 0 ;
33853 PyObject * obj0 = 0 ;
33854 PyObject * obj1 = 0 ;
33855 char * kwnames[] = {
33856 (char *) "self",(char *) "enableTheme", NULL
33857 };
33858
33859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33861 if (!SWIG_IsOK(res1)) {
33862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33863 }
33864 arg1 = reinterpret_cast< wxWindow * >(argp1);
33865 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33866 if (!SWIG_IsOK(ecode2)) {
33867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33868 }
33869 arg2 = static_cast< bool >(val2);
33870 {
33871 PyThreadState* __tstate = wxPyBeginAllowThreads();
33872 (arg1)->SetThemeEnabled(arg2);
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 resultobj = SWIG_Py_Void();
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 bool result;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 PyObject *swig_obj[1] ;
33919
33920 if (!args) SWIG_fail;
33921 swig_obj[0] = args;
33922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33923 if (!SWIG_IsOK(res1)) {
33924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33925 }
33926 arg1 = reinterpret_cast< wxWindow * >(argp1);
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->SetFocus();
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 void *argp1 = 0 ;
33944 int res1 = 0 ;
33945 PyObject *swig_obj[1] ;
33946
33947 if (!args) SWIG_fail;
33948 swig_obj[0] = args;
33949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33952 }
33953 arg1 = reinterpret_cast< wxWindow * >(argp1);
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 (arg1)->SetFocusFromKbd();
33957 wxPyEndAllowThreads(__tstate);
33958 if (PyErr_Occurred()) SWIG_fail;
33959 }
33960 resultobj = SWIG_Py_Void();
33961 return resultobj;
33962 fail:
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33968 PyObject *resultobj = 0;
33969 wxWindow *result = 0 ;
33970
33971 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33972 {
33973 if (!wxPyCheckForApp()) SWIG_fail;
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (wxWindow *)wxWindow::FindFocus();
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 {
33980 resultobj = wxPyMake_wxObject(result, 0);
33981 }
33982 return resultobj;
33983 fail:
33984 return NULL;
33985 }
33986
33987
33988 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33989 PyObject *resultobj = 0;
33990 wxWindow *arg1 = (wxWindow *) 0 ;
33991 bool result;
33992 void *argp1 = 0 ;
33993 int res1 = 0 ;
33994 PyObject *swig_obj[1] ;
33995
33996 if (!args) SWIG_fail;
33997 swig_obj[0] = args;
33998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33999 if (!SWIG_IsOK(res1)) {
34000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34001 }
34002 arg1 = reinterpret_cast< wxWindow * >(argp1);
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 {
34010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34011 }
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34019 PyObject *resultobj = 0;
34020 wxWindow *arg1 = (wxWindow *) 0 ;
34021 bool result;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 PyObject *swig_obj[1] ;
34025
34026 if (!args) SWIG_fail;
34027 swig_obj[0] = args;
34028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 {
34040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34041 }
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34052 bool result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 int val2 ;
34056 int ecode2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "flags", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34067 }
34068 arg1 = reinterpret_cast< wxWindow * >(argp1);
34069 if (obj1) {
34070 ecode2 = SWIG_AsVal_int(obj1, &val2);
34071 if (!SWIG_IsOK(ecode2)) {
34072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34073 }
34074 arg2 = static_cast< int >(val2);
34075 }
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 result = (bool)(arg1)->Navigate(arg2);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 {
34083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34084 }
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxWindow *arg2 = (wxWindow *) 0 ;
34095 void *argp1 = 0 ;
34096 int res1 = 0 ;
34097 void *argp2 = 0 ;
34098 int res2 = 0 ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char * kwnames[] = {
34102 (char *) "self",(char *) "win", NULL
34103 };
34104
34105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34107 if (!SWIG_IsOK(res1)) {
34108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34109 }
34110 arg1 = reinterpret_cast< wxWindow * >(argp1);
34111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34112 if (!SWIG_IsOK(res2)) {
34113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34114 }
34115 arg2 = reinterpret_cast< wxWindow * >(argp2);
34116 {
34117 PyThreadState* __tstate = wxPyBeginAllowThreads();
34118 (arg1)->MoveAfterInTabOrder(arg2);
34119 wxPyEndAllowThreads(__tstate);
34120 if (PyErr_Occurred()) SWIG_fail;
34121 }
34122 resultobj = SWIG_Py_Void();
34123 return resultobj;
34124 fail:
34125 return NULL;
34126 }
34127
34128
34129 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34130 PyObject *resultobj = 0;
34131 wxWindow *arg1 = (wxWindow *) 0 ;
34132 wxWindow *arg2 = (wxWindow *) 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 void *argp2 = 0 ;
34136 int res2 = 0 ;
34137 PyObject * obj0 = 0 ;
34138 PyObject * obj1 = 0 ;
34139 char * kwnames[] = {
34140 (char *) "self",(char *) "win", NULL
34141 };
34142
34143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34147 }
34148 arg1 = reinterpret_cast< wxWindow * >(argp1);
34149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34150 if (!SWIG_IsOK(res2)) {
34151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34152 }
34153 arg2 = reinterpret_cast< wxWindow * >(argp2);
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 (arg1)->MoveBeforeInTabOrder(arg2);
34157 wxPyEndAllowThreads(__tstate);
34158 if (PyErr_Occurred()) SWIG_fail;
34159 }
34160 resultobj = SWIG_Py_Void();
34161 return resultobj;
34162 fail:
34163 return NULL;
34164 }
34165
34166
34167 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34168 PyObject *resultobj = 0;
34169 wxWindow *arg1 = (wxWindow *) 0 ;
34170 PyObject *result = 0 ;
34171 void *argp1 = 0 ;
34172 int res1 = 0 ;
34173 PyObject *swig_obj[1] ;
34174
34175 if (!args) SWIG_fail;
34176 swig_obj[0] = args;
34177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (PyObject *)wxWindow_GetChildren(arg1);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = result;
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxWindow *result = 0 ;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34208 }
34209 arg1 = reinterpret_cast< wxWindow * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 {
34217 resultobj = wxPyMake_wxObject(result, 0);
34218 }
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 wxWindow *result = 0 ;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = wxPyMake_wxObject(result, 0);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *resultobj = 0;
34257 wxWindow *arg1 = (wxWindow *) 0 ;
34258 bool result;
34259 void *argp1 = 0 ;
34260 int res1 = 0 ;
34261 PyObject *swig_obj[1] ;
34262
34263 if (!args) SWIG_fail;
34264 swig_obj[0] = args;
34265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34268 }
34269 arg1 = reinterpret_cast< wxWindow * >(argp1);
34270 {
34271 PyThreadState* __tstate = wxPyBeginAllowThreads();
34272 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34273 wxPyEndAllowThreads(__tstate);
34274 if (PyErr_Occurred()) SWIG_fail;
34275 }
34276 {
34277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34278 }
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxWindow *arg2 = (wxWindow *) 0 ;
34289 bool result;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 void *argp2 = 0 ;
34293 int res2 = 0 ;
34294 PyObject * obj0 = 0 ;
34295 PyObject * obj1 = 0 ;
34296 char * kwnames[] = {
34297 (char *) "self",(char *) "newParent", NULL
34298 };
34299
34300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34302 if (!SWIG_IsOK(res1)) {
34303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34304 }
34305 arg1 = reinterpret_cast< wxWindow * >(argp1);
34306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34307 if (!SWIG_IsOK(res2)) {
34308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34309 }
34310 arg2 = reinterpret_cast< wxWindow * >(argp2);
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 result = (bool)(arg1)->Reparent(arg2);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 {
34318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34319 }
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 wxWindow *arg2 = (wxWindow *) 0 ;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 void *argp2 = 0 ;
34333 int res2 = 0 ;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 char * kwnames[] = {
34337 (char *) "self",(char *) "child", NULL
34338 };
34339
34340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res2)) {
34348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34349 }
34350 arg2 = reinterpret_cast< wxWindow * >(argp2);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 (arg1)->AddChild(arg2);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 resultobj = SWIG_Py_Void();
34358 return resultobj;
34359 fail:
34360 return NULL;
34361 }
34362
34363
34364 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34365 PyObject *resultobj = 0;
34366 wxWindow *arg1 = (wxWindow *) 0 ;
34367 wxWindow *arg2 = (wxWindow *) 0 ;
34368 void *argp1 = 0 ;
34369 int res1 = 0 ;
34370 void *argp2 = 0 ;
34371 int res2 = 0 ;
34372 PyObject * obj0 = 0 ;
34373 PyObject * obj1 = 0 ;
34374 char * kwnames[] = {
34375 (char *) "self",(char *) "child", NULL
34376 };
34377
34378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34380 if (!SWIG_IsOK(res1)) {
34381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34382 }
34383 arg1 = reinterpret_cast< wxWindow * >(argp1);
34384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34385 if (!SWIG_IsOK(res2)) {
34386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34387 }
34388 arg2 = reinterpret_cast< wxWindow * >(argp2);
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->RemoveChild(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_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 bool arg2 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 bool val2 ;
34409 int ecode2 = 0 ;
34410 PyObject * obj0 = 0 ;
34411 PyObject * obj1 = 0 ;
34412 char * kwnames[] = {
34413 (char *) "self",(char *) "on", NULL
34414 };
34415
34416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34418 if (!SWIG_IsOK(res1)) {
34419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34420 }
34421 arg1 = reinterpret_cast< wxWindow * >(argp1);
34422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34423 if (!SWIG_IsOK(ecode2)) {
34424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34425 }
34426 arg2 = static_cast< bool >(val2);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 wxWindow_SetDoubleBuffered(arg1,arg2);
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 resultobj = SWIG_Py_Void();
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34441 PyObject *resultobj = 0;
34442 wxWindow *arg1 = (wxWindow *) 0 ;
34443 long arg2 ;
34444 wxWindow *result = 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 long val2 ;
34448 int ecode2 = 0 ;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char * kwnames[] = {
34452 (char *) "self",(char *) "winid", NULL
34453 };
34454
34455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34459 }
34460 arg1 = reinterpret_cast< wxWindow * >(argp1);
34461 ecode2 = SWIG_AsVal_long(obj1, &val2);
34462 if (!SWIG_IsOK(ecode2)) {
34463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34464 }
34465 arg2 = static_cast< long >(val2);
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 result = (wxWindow *)(arg1)->FindWindow(arg2);
34469 wxPyEndAllowThreads(__tstate);
34470 if (PyErr_Occurred()) SWIG_fail;
34471 }
34472 {
34473 resultobj = wxPyMake_wxObject(result, 0);
34474 }
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34482 PyObject *resultobj = 0;
34483 wxWindow *arg1 = (wxWindow *) 0 ;
34484 wxString *arg2 = 0 ;
34485 wxWindow *result = 0 ;
34486 void *argp1 = 0 ;
34487 int res1 = 0 ;
34488 bool temp2 = false ;
34489 PyObject * obj0 = 0 ;
34490 PyObject * obj1 = 0 ;
34491 char * kwnames[] = {
34492 (char *) "self",(char *) "name", NULL
34493 };
34494
34495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34497 if (!SWIG_IsOK(res1)) {
34498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34499 }
34500 arg1 = reinterpret_cast< wxWindow * >(argp1);
34501 {
34502 arg2 = wxString_in_helper(obj1);
34503 if (arg2 == NULL) SWIG_fail;
34504 temp2 = true;
34505 }
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 {
34513 resultobj = wxPyMake_wxObject(result, 0);
34514 }
34515 {
34516 if (temp2)
34517 delete arg2;
34518 }
34519 return resultobj;
34520 fail:
34521 {
34522 if (temp2)
34523 delete arg2;
34524 }
34525 return NULL;
34526 }
34527
34528
34529 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 PyObject *resultobj = 0;
34531 wxWindow *arg1 = (wxWindow *) 0 ;
34532 wxEvtHandler *result = 0 ;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34542 }
34543 arg1 = reinterpret_cast< wxWindow * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 {
34551 resultobj = wxPyMake_wxObject(result, 0);
34552 }
34553 return resultobj;
34554 fail:
34555 return NULL;
34556 }
34557
34558
34559 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34560 PyObject *resultobj = 0;
34561 wxWindow *arg1 = (wxWindow *) 0 ;
34562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 void *argp2 = 0 ;
34566 int res2 = 0 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char * kwnames[] = {
34570 (char *) "self",(char *) "handler", NULL
34571 };
34572
34573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34580 if (!SWIG_IsOK(res2)) {
34581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34582 }
34583 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 (arg1)->SetEventHandler(arg2);
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_Py_Void();
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = 0;
34599 wxWindow *arg1 = (wxWindow *) 0 ;
34600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 void *argp2 = 0 ;
34604 int res2 = 0 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "handler", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34615 }
34616 arg1 = reinterpret_cast< wxWindow * >(argp1);
34617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34618 if (!SWIG_IsOK(res2)) {
34619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34620 }
34621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 (arg1)->PushEventHandler(arg2);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_Py_Void();
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34636 PyObject *resultobj = 0;
34637 wxWindow *arg1 = (wxWindow *) 0 ;
34638 bool arg2 = (bool) false ;
34639 wxEvtHandler *result = 0 ;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 bool val2 ;
34643 int ecode2 = 0 ;
34644 PyObject * obj0 = 0 ;
34645 PyObject * obj1 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "self",(char *) "deleteHandler", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34652 if (!SWIG_IsOK(res1)) {
34653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34654 }
34655 arg1 = reinterpret_cast< wxWindow * >(argp1);
34656 if (obj1) {
34657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34658 if (!SWIG_IsOK(ecode2)) {
34659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34660 }
34661 arg2 = static_cast< bool >(val2);
34662 }
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 {
34670 resultobj = wxPyMake_wxObject(result, 0);
34671 }
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj = 0;
34680 wxWindow *arg1 = (wxWindow *) 0 ;
34681 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34682 bool result;
34683 void *argp1 = 0 ;
34684 int res1 = 0 ;
34685 void *argp2 = 0 ;
34686 int res2 = 0 ;
34687 PyObject * obj0 = 0 ;
34688 PyObject * obj1 = 0 ;
34689 char * kwnames[] = {
34690 (char *) "self",(char *) "handler", NULL
34691 };
34692
34693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34695 if (!SWIG_IsOK(res1)) {
34696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34697 }
34698 arg1 = reinterpret_cast< wxWindow * >(argp1);
34699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34700 if (!SWIG_IsOK(res2)) {
34701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34702 }
34703 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34704 {
34705 PyThreadState* __tstate = wxPyBeginAllowThreads();
34706 result = (bool)(arg1)->RemoveEventHandler(arg2);
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 {
34711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34712 }
34713 return resultobj;
34714 fail:
34715 return NULL;
34716 }
34717
34718
34719 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34720 PyObject *resultobj = 0;
34721 wxWindow *arg1 = (wxWindow *) 0 ;
34722 wxValidator *arg2 = 0 ;
34723 void *argp1 = 0 ;
34724 int res1 = 0 ;
34725 void *argp2 = 0 ;
34726 int res2 = 0 ;
34727 PyObject * obj0 = 0 ;
34728 PyObject * obj1 = 0 ;
34729 char * kwnames[] = {
34730 (char *) "self",(char *) "validator", NULL
34731 };
34732
34733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34737 }
34738 arg1 = reinterpret_cast< wxWindow * >(argp1);
34739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34740 if (!SWIG_IsOK(res2)) {
34741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34742 }
34743 if (!argp2) {
34744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34745 }
34746 arg2 = reinterpret_cast< wxValidator * >(argp2);
34747 {
34748 PyThreadState* __tstate = wxPyBeginAllowThreads();
34749 (arg1)->SetValidator((wxValidator const &)*arg2);
34750 wxPyEndAllowThreads(__tstate);
34751 if (PyErr_Occurred()) SWIG_fail;
34752 }
34753 resultobj = SWIG_Py_Void();
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34761 PyObject *resultobj = 0;
34762 wxWindow *arg1 = (wxWindow *) 0 ;
34763 wxValidator *result = 0 ;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 PyObject *swig_obj[1] ;
34767
34768 if (!args) SWIG_fail;
34769 swig_obj[0] = args;
34770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34773 }
34774 arg1 = reinterpret_cast< wxWindow * >(argp1);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (wxValidator *)(arg1)->GetValidator();
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 {
34782 resultobj = wxPyMake_wxObject(result, (bool)0);
34783 }
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 bool result;
34794 void *argp1 = 0 ;
34795 int res1 = 0 ;
34796 PyObject *swig_obj[1] ;
34797
34798 if (!args) SWIG_fail;
34799 swig_obj[0] = args;
34800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34803 }
34804 arg1 = reinterpret_cast< wxWindow * >(argp1);
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 result = (bool)(arg1)->Validate();
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 {
34812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34813 }
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34821 PyObject *resultobj = 0;
34822 wxWindow *arg1 = (wxWindow *) 0 ;
34823 bool result;
34824 void *argp1 = 0 ;
34825 int res1 = 0 ;
34826 PyObject *swig_obj[1] ;
34827
34828 if (!args) SWIG_fail;
34829 swig_obj[0] = args;
34830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34833 }
34834 arg1 = reinterpret_cast< wxWindow * >(argp1);
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 result = (bool)(arg1)->TransferDataToWindow();
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 {
34842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34843 }
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 bool 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_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = (bool)(arg1)->TransferDataFromWindow();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34881 PyObject *resultobj = 0;
34882 wxWindow *arg1 = (wxWindow *) 0 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 PyObject *swig_obj[1] ;
34886
34887 if (!args) SWIG_fail;
34888 swig_obj[0] = args;
34889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34890 if (!SWIG_IsOK(res1)) {
34891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34892 }
34893 arg1 = reinterpret_cast< wxWindow * >(argp1);
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 (arg1)->InitDialog();
34897 wxPyEndAllowThreads(__tstate);
34898 if (PyErr_Occurred()) SWIG_fail;
34899 }
34900 resultobj = SWIG_Py_Void();
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj = 0;
34909 wxWindow *arg1 = (wxWindow *) 0 ;
34910 wxAcceleratorTable *arg2 = 0 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 void *argp2 = 0 ;
34914 int res2 = 0 ;
34915 PyObject * obj0 = 0 ;
34916 PyObject * obj1 = 0 ;
34917 char * kwnames[] = {
34918 (char *) "self",(char *) "accel", NULL
34919 };
34920
34921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34925 }
34926 arg1 = reinterpret_cast< wxWindow * >(argp1);
34927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34928 if (!SWIG_IsOK(res2)) {
34929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34930 }
34931 if (!argp2) {
34932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34933 }
34934 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34935 {
34936 PyThreadState* __tstate = wxPyBeginAllowThreads();
34937 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 resultobj = SWIG_Py_Void();
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34949 PyObject *resultobj = 0;
34950 wxWindow *arg1 = (wxWindow *) 0 ;
34951 wxAcceleratorTable *result = 0 ;
34952 void *argp1 = 0 ;
34953 int res1 = 0 ;
34954 PyObject *swig_obj[1] ;
34955
34956 if (!args) SWIG_fail;
34957 swig_obj[0] = args;
34958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34959 if (!SWIG_IsOK(res1)) {
34960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34961 }
34962 arg1 = reinterpret_cast< wxWindow * >(argp1);
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj = 0;
34978 wxWindow *arg1 = (wxWindow *) 0 ;
34979 int arg2 ;
34980 int arg3 ;
34981 int arg4 ;
34982 bool result;
34983 void *argp1 = 0 ;
34984 int res1 = 0 ;
34985 int val2 ;
34986 int ecode2 = 0 ;
34987 int val3 ;
34988 int ecode3 = 0 ;
34989 int val4 ;
34990 int ecode4 = 0 ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 PyObject * obj2 = 0 ;
34994 PyObject * obj3 = 0 ;
34995 char * kwnames[] = {
34996 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34997 };
34998
34999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35003 }
35004 arg1 = reinterpret_cast< wxWindow * >(argp1);
35005 ecode2 = SWIG_AsVal_int(obj1, &val2);
35006 if (!SWIG_IsOK(ecode2)) {
35007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35008 }
35009 arg2 = static_cast< int >(val2);
35010 ecode3 = SWIG_AsVal_int(obj2, &val3);
35011 if (!SWIG_IsOK(ecode3)) {
35012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35013 }
35014 arg3 = static_cast< int >(val3);
35015 ecode4 = SWIG_AsVal_int(obj3, &val4);
35016 if (!SWIG_IsOK(ecode4)) {
35017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35018 }
35019 arg4 = static_cast< int >(val4);
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35028 }
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 int arg2 ;
35039 bool result;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 int val2 ;
35043 int ecode2 = 0 ;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "hotkeyId", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 ecode2 = SWIG_AsVal_int(obj1, &val2);
35057 if (!SWIG_IsOK(ecode2)) {
35058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35059 }
35060 arg2 = static_cast< int >(val2);
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 {
35068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35069 }
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxPoint *arg2 = 0 ;
35080 wxPoint result;
35081 void *argp1 = 0 ;
35082 int res1 = 0 ;
35083 wxPoint temp2 ;
35084 PyObject * obj0 = 0 ;
35085 PyObject * obj1 = 0 ;
35086 char * kwnames[] = {
35087 (char *) "self",(char *) "pt", NULL
35088 };
35089
35090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35092 if (!SWIG_IsOK(res1)) {
35093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35094 }
35095 arg1 = reinterpret_cast< wxWindow * >(argp1);
35096 {
35097 arg2 = &temp2;
35098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35099 }
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35114 PyObject *resultobj = 0;
35115 wxWindow *arg1 = (wxWindow *) 0 ;
35116 wxSize *arg2 = 0 ;
35117 wxSize result;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 wxSize temp2 ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char * kwnames[] = {
35124 (char *) "self",(char *) "sz", NULL
35125 };
35126
35127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 arg2 = &temp2;
35135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj = 0;
35152 wxWindow *arg1 = (wxWindow *) 0 ;
35153 wxPoint *arg2 = 0 ;
35154 wxPoint result;
35155 void *argp1 = 0 ;
35156 int res1 = 0 ;
35157 wxPoint temp2 ;
35158 PyObject * obj0 = 0 ;
35159 PyObject * obj1 = 0 ;
35160 char * kwnames[] = {
35161 (char *) "self",(char *) "pt", NULL
35162 };
35163
35164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35166 if (!SWIG_IsOK(res1)) {
35167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35168 }
35169 arg1 = reinterpret_cast< wxWindow * >(argp1);
35170 {
35171 arg2 = &temp2;
35172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35173 }
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 wxSize *arg2 = 0 ;
35191 wxSize result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 wxSize temp2 ;
35195 PyObject * obj0 = 0 ;
35196 PyObject * obj1 = 0 ;
35197 char * kwnames[] = {
35198 (char *) "self",(char *) "sz", NULL
35199 };
35200
35201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 arg2 = &temp2;
35209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35210 }
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35218 return resultobj;
35219 fail:
35220 return NULL;
35221 }
35222
35223
35224 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35225 PyObject *resultobj = 0;
35226 wxWindow *arg1 = (wxWindow *) 0 ;
35227 wxPoint *arg2 = 0 ;
35228 wxPoint result;
35229 void *argp1 = 0 ;
35230 int res1 = 0 ;
35231 wxPoint temp2 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 char * kwnames[] = {
35235 (char *) "self",(char *) "pt", NULL
35236 };
35237
35238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35242 }
35243 arg1 = reinterpret_cast< wxWindow * >(argp1);
35244 {
35245 arg2 = &temp2;
35246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35247 }
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35251 wxPyEndAllowThreads(__tstate);
35252 if (PyErr_Occurred()) SWIG_fail;
35253 }
35254 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj = 0;
35263 wxWindow *arg1 = (wxWindow *) 0 ;
35264 wxSize *arg2 = 0 ;
35265 wxSize result;
35266 void *argp1 = 0 ;
35267 int res1 = 0 ;
35268 wxSize temp2 ;
35269 PyObject * obj0 = 0 ;
35270 PyObject * obj1 = 0 ;
35271 char * kwnames[] = {
35272 (char *) "self",(char *) "sz", NULL
35273 };
35274
35275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35277 if (!SWIG_IsOK(res1)) {
35278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35279 }
35280 arg1 = reinterpret_cast< wxWindow * >(argp1);
35281 {
35282 arg2 = &temp2;
35283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35284 }
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 int arg2 ;
35302 int arg3 ;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 int val2 ;
35306 int ecode2 = 0 ;
35307 int val3 ;
35308 int ecode3 = 0 ;
35309 PyObject * obj0 = 0 ;
35310 PyObject * obj1 = 0 ;
35311 PyObject * obj2 = 0 ;
35312 char * kwnames[] = {
35313 (char *) "self",(char *) "x",(char *) "y", NULL
35314 };
35315
35316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35320 }
35321 arg1 = reinterpret_cast< wxWindow * >(argp1);
35322 ecode2 = SWIG_AsVal_int(obj1, &val2);
35323 if (!SWIG_IsOK(ecode2)) {
35324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35325 }
35326 arg2 = static_cast< int >(val2);
35327 ecode3 = SWIG_AsVal_int(obj2, &val3);
35328 if (!SWIG_IsOK(ecode3)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35330 }
35331 arg3 = static_cast< int >(val3);
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 (arg1)->WarpPointer(arg2,arg3);
35335 wxPyEndAllowThreads(__tstate);
35336 if (PyErr_Occurred()) SWIG_fail;
35337 }
35338 resultobj = SWIG_Py_Void();
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35346 PyObject *resultobj = 0;
35347 wxWindow *arg1 = (wxWindow *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 PyObject *swig_obj[1] ;
35351
35352 if (!args) SWIG_fail;
35353 swig_obj[0] = args;
35354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->CaptureMouse();
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_Py_Void();
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxWindow *arg1 = (wxWindow *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 (arg1)->ReleaseMouse();
35389 wxPyEndAllowThreads(__tstate);
35390 if (PyErr_Occurred()) SWIG_fail;
35391 }
35392 resultobj = SWIG_Py_Void();
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35400 PyObject *resultobj = 0;
35401 wxWindow *result = 0 ;
35402
35403 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35404 {
35405 if (!wxPyCheckForApp()) SWIG_fail;
35406 PyThreadState* __tstate = wxPyBeginAllowThreads();
35407 result = (wxWindow *)wxWindow::GetCapture();
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = wxPyMake_wxObject(result, 0);
35413 }
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 bool result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (bool)((wxWindow const *)arg1)->HasCapture();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 {
35442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35443 }
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35451 PyObject *resultobj = 0;
35452 wxWindow *arg1 = (wxWindow *) 0 ;
35453 bool arg2 = (bool) true ;
35454 wxRect *arg3 = (wxRect *) NULL ;
35455 void *argp1 = 0 ;
35456 int res1 = 0 ;
35457 bool val2 ;
35458 int ecode2 = 0 ;
35459 void *argp3 = 0 ;
35460 int res3 = 0 ;
35461 PyObject * obj0 = 0 ;
35462 PyObject * obj1 = 0 ;
35463 PyObject * obj2 = 0 ;
35464 char * kwnames[] = {
35465 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35466 };
35467
35468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35470 if (!SWIG_IsOK(res1)) {
35471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35472 }
35473 arg1 = reinterpret_cast< wxWindow * >(argp1);
35474 if (obj1) {
35475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35476 if (!SWIG_IsOK(ecode2)) {
35477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35478 }
35479 arg2 = static_cast< bool >(val2);
35480 }
35481 if (obj2) {
35482 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35483 if (!SWIG_IsOK(res3)) {
35484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35485 }
35486 arg3 = reinterpret_cast< wxRect * >(argp3);
35487 }
35488 {
35489 PyThreadState* __tstate = wxPyBeginAllowThreads();
35490 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 resultobj = SWIG_Py_Void();
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 wxRect *arg2 = 0 ;
35505 bool arg3 = (bool) true ;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 wxRect temp2 ;
35509 bool val3 ;
35510 int ecode3 = 0 ;
35511 PyObject * obj0 = 0 ;
35512 PyObject * obj1 = 0 ;
35513 PyObject * obj2 = 0 ;
35514 char * kwnames[] = {
35515 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35516 };
35517
35518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35520 if (!SWIG_IsOK(res1)) {
35521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35522 }
35523 arg1 = reinterpret_cast< wxWindow * >(argp1);
35524 {
35525 arg2 = &temp2;
35526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35527 }
35528 if (obj2) {
35529 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35530 if (!SWIG_IsOK(ecode3)) {
35531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35532 }
35533 arg3 = static_cast< bool >(val3);
35534 }
35535 {
35536 PyThreadState* __tstate = wxPyBeginAllowThreads();
35537 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35538 wxPyEndAllowThreads(__tstate);
35539 if (PyErr_Occurred()) SWIG_fail;
35540 }
35541 resultobj = SWIG_Py_Void();
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35549 PyObject *resultobj = 0;
35550 wxWindow *arg1 = (wxWindow *) 0 ;
35551 void *argp1 = 0 ;
35552 int res1 = 0 ;
35553 PyObject *swig_obj[1] ;
35554
35555 if (!args) SWIG_fail;
35556 swig_obj[0] = args;
35557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35558 if (!SWIG_IsOK(res1)) {
35559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35560 }
35561 arg1 = reinterpret_cast< wxWindow * >(argp1);
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 (arg1)->Update();
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 resultobj = SWIG_Py_Void();
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35576 PyObject *resultobj = 0;
35577 wxWindow *arg1 = (wxWindow *) 0 ;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 PyObject *swig_obj[1] ;
35581
35582 if (!args) SWIG_fail;
35583 swig_obj[0] = args;
35584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 (arg1)->ClearBackground();
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 resultobj = SWIG_Py_Void();
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35603 PyObject *resultobj = 0;
35604 wxWindow *arg1 = (wxWindow *) 0 ;
35605 void *argp1 = 0 ;
35606 int res1 = 0 ;
35607 PyObject *swig_obj[1] ;
35608
35609 if (!args) SWIG_fail;
35610 swig_obj[0] = args;
35611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35612 if (!SWIG_IsOK(res1)) {
35613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35614 }
35615 arg1 = reinterpret_cast< wxWindow * >(argp1);
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 (arg1)->Freeze();
35619 wxPyEndAllowThreads(__tstate);
35620 if (PyErr_Occurred()) SWIG_fail;
35621 }
35622 resultobj = SWIG_Py_Void();
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35630 PyObject *resultobj = 0;
35631 wxWindow *arg1 = (wxWindow *) 0 ;
35632 bool result;
35633 void *argp1 = 0 ;
35634 int res1 = 0 ;
35635 PyObject *swig_obj[1] ;
35636
35637 if (!args) SWIG_fail;
35638 swig_obj[0] = args;
35639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35640 if (!SWIG_IsOK(res1)) {
35641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35642 }
35643 arg1 = reinterpret_cast< wxWindow * >(argp1);
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35647 wxPyEndAllowThreads(__tstate);
35648 if (PyErr_Occurred()) SWIG_fail;
35649 }
35650 {
35651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35652 }
35653 return resultobj;
35654 fail:
35655 return NULL;
35656 }
35657
35658
35659 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35660 PyObject *resultobj = 0;
35661 wxWindow *arg1 = (wxWindow *) 0 ;
35662 void *argp1 = 0 ;
35663 int res1 = 0 ;
35664 PyObject *swig_obj[1] ;
35665
35666 if (!args) SWIG_fail;
35667 swig_obj[0] = args;
35668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35669 if (!SWIG_IsOK(res1)) {
35670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35671 }
35672 arg1 = reinterpret_cast< wxWindow * >(argp1);
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 (arg1)->Thaw();
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 resultobj = SWIG_Py_Void();
35680 return resultobj;
35681 fail:
35682 return NULL;
35683 }
35684
35685
35686 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35687 PyObject *resultobj = 0;
35688 wxWindow *arg1 = (wxWindow *) 0 ;
35689 wxDC *arg2 = 0 ;
35690 void *argp1 = 0 ;
35691 int res1 = 0 ;
35692 void *argp2 = 0 ;
35693 int res2 = 0 ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 char * kwnames[] = {
35697 (char *) "self",(char *) "dc", NULL
35698 };
35699
35700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35702 if (!SWIG_IsOK(res1)) {
35703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35704 }
35705 arg1 = reinterpret_cast< wxWindow * >(argp1);
35706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35707 if (!SWIG_IsOK(res2)) {
35708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35709 }
35710 if (!argp2) {
35711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35712 }
35713 arg2 = reinterpret_cast< wxDC * >(argp2);
35714 {
35715 PyThreadState* __tstate = wxPyBeginAllowThreads();
35716 (arg1)->PrepareDC(*arg2);
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 resultobj = SWIG_Py_Void();
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35728 PyObject *resultobj = 0;
35729 wxWindow *arg1 = (wxWindow *) 0 ;
35730 bool result;
35731 void *argp1 = 0 ;
35732 int res1 = 0 ;
35733 PyObject *swig_obj[1] ;
35734
35735 if (!args) SWIG_fail;
35736 swig_obj[0] = args;
35737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35738 if (!SWIG_IsOK(res1)) {
35739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35740 }
35741 arg1 = reinterpret_cast< wxWindow * >(argp1);
35742 {
35743 PyThreadState* __tstate = wxPyBeginAllowThreads();
35744 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35745 wxPyEndAllowThreads(__tstate);
35746 if (PyErr_Occurred()) SWIG_fail;
35747 }
35748 {
35749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35750 }
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35758 PyObject *resultobj = 0;
35759 wxWindow *arg1 = (wxWindow *) 0 ;
35760 wxRegion *result = 0 ;
35761 void *argp1 = 0 ;
35762 int res1 = 0 ;
35763 PyObject *swig_obj[1] ;
35764
35765 if (!args) SWIG_fail;
35766 swig_obj[0] = args;
35767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35768 if (!SWIG_IsOK(res1)) {
35769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35770 }
35771 arg1 = reinterpret_cast< wxWindow * >(argp1);
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 {
35775 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35776 result = (wxRegion *) &_result_ref;
35777 }
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35789 PyObject *resultobj = 0;
35790 wxWindow *arg1 = (wxWindow *) 0 ;
35791 wxRect result;
35792 void *argp1 = 0 ;
35793 int res1 = 0 ;
35794 PyObject *swig_obj[1] ;
35795
35796 if (!args) SWIG_fail;
35797 swig_obj[0] = args;
35798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35799 if (!SWIG_IsOK(res1)) {
35800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35801 }
35802 arg1 = reinterpret_cast< wxWindow * >(argp1);
35803 {
35804 PyThreadState* __tstate = wxPyBeginAllowThreads();
35805 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35806 wxPyEndAllowThreads(__tstate);
35807 if (PyErr_Occurred()) SWIG_fail;
35808 }
35809 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35810 return resultobj;
35811 fail:
35812 return NULL;
35813 }
35814
35815
35816 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35817 PyObject *resultobj = 0;
35818 wxWindow *arg1 = (wxWindow *) 0 ;
35819 int arg2 ;
35820 int arg3 ;
35821 int arg4 = (int) 1 ;
35822 int arg5 = (int) 1 ;
35823 bool result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 int val2 ;
35827 int ecode2 = 0 ;
35828 int val3 ;
35829 int ecode3 = 0 ;
35830 int val4 ;
35831 int ecode4 = 0 ;
35832 int val5 ;
35833 int ecode5 = 0 ;
35834 PyObject * obj0 = 0 ;
35835 PyObject * obj1 = 0 ;
35836 PyObject * obj2 = 0 ;
35837 PyObject * obj3 = 0 ;
35838 PyObject * obj4 = 0 ;
35839 char * kwnames[] = {
35840 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35841 };
35842
35843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35845 if (!SWIG_IsOK(res1)) {
35846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35847 }
35848 arg1 = reinterpret_cast< wxWindow * >(argp1);
35849 ecode2 = SWIG_AsVal_int(obj1, &val2);
35850 if (!SWIG_IsOK(ecode2)) {
35851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35852 }
35853 arg2 = static_cast< int >(val2);
35854 ecode3 = SWIG_AsVal_int(obj2, &val3);
35855 if (!SWIG_IsOK(ecode3)) {
35856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35857 }
35858 arg3 = static_cast< int >(val3);
35859 if (obj3) {
35860 ecode4 = SWIG_AsVal_int(obj3, &val4);
35861 if (!SWIG_IsOK(ecode4)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35863 }
35864 arg4 = static_cast< int >(val4);
35865 }
35866 if (obj4) {
35867 ecode5 = SWIG_AsVal_int(obj4, &val5);
35868 if (!SWIG_IsOK(ecode5)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35870 }
35871 arg5 = static_cast< int >(val5);
35872 }
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35881 }
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 wxPoint *arg2 = 0 ;
35892 bool result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 wxPoint temp2 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 char * kwnames[] = {
35899 (char *) "self",(char *) "pt", NULL
35900 };
35901
35902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35904 if (!SWIG_IsOK(res1)) {
35905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35906 }
35907 arg1 = reinterpret_cast< wxWindow * >(argp1);
35908 {
35909 arg2 = &temp2;
35910 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 {
35919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35920 }
35921 return resultobj;
35922 fail:
35923 return NULL;
35924 }
35925
35926
35927 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35928 PyObject *resultobj = 0;
35929 wxWindow *arg1 = (wxWindow *) 0 ;
35930 wxRect *arg2 = 0 ;
35931 bool result;
35932 void *argp1 = 0 ;
35933 int res1 = 0 ;
35934 wxRect temp2 ;
35935 PyObject * obj0 = 0 ;
35936 PyObject * obj1 = 0 ;
35937 char * kwnames[] = {
35938 (char *) "self",(char *) "rect", NULL
35939 };
35940
35941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35943 if (!SWIG_IsOK(res1)) {
35944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35945 }
35946 arg1 = reinterpret_cast< wxWindow * >(argp1);
35947 {
35948 arg2 = &temp2;
35949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35950 }
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 {
35958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35959 }
35960 return resultobj;
35961 fail:
35962 return NULL;
35963 }
35964
35965
35966 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35967 PyObject *resultobj = 0;
35968 wxWindow *arg1 = (wxWindow *) 0 ;
35969 SwigValueWrapper<wxVisualAttributes > result;
35970 void *argp1 = 0 ;
35971 int res1 = 0 ;
35972 PyObject *swig_obj[1] ;
35973
35974 if (!args) SWIG_fail;
35975 swig_obj[0] = args;
35976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35977 if (!SWIG_IsOK(res1)) {
35978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35979 }
35980 arg1 = reinterpret_cast< wxWindow * >(argp1);
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35988 return resultobj;
35989 fail:
35990 return NULL;
35991 }
35992
35993
35994 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35995 PyObject *resultobj = 0;
35996 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35997 SwigValueWrapper<wxVisualAttributes > result;
35998 int val1 ;
35999 int ecode1 = 0 ;
36000 PyObject * obj0 = 0 ;
36001 char * kwnames[] = {
36002 (char *) "variant", NULL
36003 };
36004
36005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36006 if (obj0) {
36007 ecode1 = SWIG_AsVal_int(obj0, &val1);
36008 if (!SWIG_IsOK(ecode1)) {
36009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36010 }
36011 arg1 = static_cast< wxWindowVariant >(val1);
36012 }
36013 {
36014 if (!wxPyCheckForApp()) SWIG_fail;
36015 PyThreadState* __tstate = wxPyBeginAllowThreads();
36016 result = wxWindow::GetClassDefaultAttributes(arg1);
36017 wxPyEndAllowThreads(__tstate);
36018 if (PyErr_Occurred()) SWIG_fail;
36019 }
36020 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36028 PyObject *resultobj = 0;
36029 wxWindow *arg1 = (wxWindow *) 0 ;
36030 wxColour *arg2 = 0 ;
36031 bool result;
36032 void *argp1 = 0 ;
36033 int res1 = 0 ;
36034 wxColour temp2 ;
36035 PyObject * obj0 = 0 ;
36036 PyObject * obj1 = 0 ;
36037 char * kwnames[] = {
36038 (char *) "self",(char *) "colour", NULL
36039 };
36040
36041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36045 }
36046 arg1 = reinterpret_cast< wxWindow * >(argp1);
36047 {
36048 arg2 = &temp2;
36049 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36050 }
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 {
36058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36059 }
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36067 PyObject *resultobj = 0;
36068 wxWindow *arg1 = (wxWindow *) 0 ;
36069 wxColour *arg2 = 0 ;
36070 void *argp1 = 0 ;
36071 int res1 = 0 ;
36072 wxColour temp2 ;
36073 PyObject * obj0 = 0 ;
36074 PyObject * obj1 = 0 ;
36075 char * kwnames[] = {
36076 (char *) "self",(char *) "colour", NULL
36077 };
36078
36079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36083 }
36084 arg1 = reinterpret_cast< wxWindow * >(argp1);
36085 {
36086 arg2 = &temp2;
36087 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36088 }
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 resultobj = SWIG_Py_Void();
36096 return resultobj;
36097 fail:
36098 return NULL;
36099 }
36100
36101
36102 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36103 PyObject *resultobj = 0;
36104 wxWindow *arg1 = (wxWindow *) 0 ;
36105 wxColour *arg2 = 0 ;
36106 bool result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 wxColour temp2 ;
36110 PyObject * obj0 = 0 ;
36111 PyObject * obj1 = 0 ;
36112 char * kwnames[] = {
36113 (char *) "self",(char *) "colour", NULL
36114 };
36115
36116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36120 }
36121 arg1 = reinterpret_cast< wxWindow * >(argp1);
36122 {
36123 arg2 = &temp2;
36124 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36125 }
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 {
36133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36134 }
36135 return resultobj;
36136 fail:
36137 return NULL;
36138 }
36139
36140
36141 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36142 PyObject *resultobj = 0;
36143 wxWindow *arg1 = (wxWindow *) 0 ;
36144 wxColour *arg2 = 0 ;
36145 void *argp1 = 0 ;
36146 int res1 = 0 ;
36147 wxColour temp2 ;
36148 PyObject * obj0 = 0 ;
36149 PyObject * obj1 = 0 ;
36150 char * kwnames[] = {
36151 (char *) "self",(char *) "colour", NULL
36152 };
36153
36154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36156 if (!SWIG_IsOK(res1)) {
36157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36158 }
36159 arg1 = reinterpret_cast< wxWindow * >(argp1);
36160 {
36161 arg2 = &temp2;
36162 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36163 }
36164 {
36165 PyThreadState* __tstate = wxPyBeginAllowThreads();
36166 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36167 wxPyEndAllowThreads(__tstate);
36168 if (PyErr_Occurred()) SWIG_fail;
36169 }
36170 resultobj = SWIG_Py_Void();
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36178 PyObject *resultobj = 0;
36179 wxWindow *arg1 = (wxWindow *) 0 ;
36180 wxColour result;
36181 void *argp1 = 0 ;
36182 int res1 = 0 ;
36183 PyObject *swig_obj[1] ;
36184
36185 if (!args) SWIG_fail;
36186 swig_obj[0] = args;
36187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36188 if (!SWIG_IsOK(res1)) {
36189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36190 }
36191 arg1 = reinterpret_cast< wxWindow * >(argp1);
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36195 wxPyEndAllowThreads(__tstate);
36196 if (PyErr_Occurred()) SWIG_fail;
36197 }
36198 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36199 return resultobj;
36200 fail:
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36206 PyObject *resultobj = 0;
36207 wxWindow *arg1 = (wxWindow *) 0 ;
36208 wxColour result;
36209 void *argp1 = 0 ;
36210 int res1 = 0 ;
36211 PyObject *swig_obj[1] ;
36212
36213 if (!args) SWIG_fail;
36214 swig_obj[0] = args;
36215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36218 }
36219 arg1 = reinterpret_cast< wxWindow * >(argp1);
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 result = ((wxWindow const *)arg1)->GetForegroundColour();
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 bool result;
36237 void *argp1 = 0 ;
36238 int res1 = 0 ;
36239 PyObject *swig_obj[1] ;
36240
36241 if (!args) SWIG_fail;
36242 swig_obj[0] = args;
36243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36244 if (!SWIG_IsOK(res1)) {
36245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36246 }
36247 arg1 = reinterpret_cast< wxWindow * >(argp1);
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 {
36255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36256 }
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36264 PyObject *resultobj = 0;
36265 wxWindow *arg1 = (wxWindow *) 0 ;
36266 bool result;
36267 void *argp1 = 0 ;
36268 int res1 = 0 ;
36269 PyObject *swig_obj[1] ;
36270
36271 if (!args) SWIG_fail;
36272 swig_obj[0] = args;
36273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36274 if (!SWIG_IsOK(res1)) {
36275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36276 }
36277 arg1 = reinterpret_cast< wxWindow * >(argp1);
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36281 wxPyEndAllowThreads(__tstate);
36282 if (PyErr_Occurred()) SWIG_fail;
36283 }
36284 {
36285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36286 }
36287 return resultobj;
36288 fail:
36289 return NULL;
36290 }
36291
36292
36293 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36294 PyObject *resultobj = 0;
36295 wxWindow *arg1 = (wxWindow *) 0 ;
36296 wxBackgroundStyle arg2 ;
36297 bool result;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 int val2 ;
36301 int ecode2 = 0 ;
36302 PyObject * obj0 = 0 ;
36303 PyObject * obj1 = 0 ;
36304 char * kwnames[] = {
36305 (char *) "self",(char *) "style", NULL
36306 };
36307
36308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36310 if (!SWIG_IsOK(res1)) {
36311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36312 }
36313 arg1 = reinterpret_cast< wxWindow * >(argp1);
36314 ecode2 = SWIG_AsVal_int(obj1, &val2);
36315 if (!SWIG_IsOK(ecode2)) {
36316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36317 }
36318 arg2 = static_cast< wxBackgroundStyle >(val2);
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36322 wxPyEndAllowThreads(__tstate);
36323 if (PyErr_Occurred()) SWIG_fail;
36324 }
36325 {
36326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36327 }
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 wxBackgroundStyle result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36347 }
36348 arg1 = reinterpret_cast< wxWindow * >(argp1);
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 resultobj = SWIG_From_int(static_cast< int >(result));
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 bool result;
36366 void *argp1 = 0 ;
36367 int res1 = 0 ;
36368 PyObject *swig_obj[1] ;
36369
36370 if (!args) SWIG_fail;
36371 swig_obj[0] = args;
36372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36373 if (!SWIG_IsOK(res1)) {
36374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36375 }
36376 arg1 = reinterpret_cast< wxWindow * >(argp1);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (bool)(arg1)->HasTransparentBackground();
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 wxCursor *arg2 = 0 ;
36396 bool result;
36397 void *argp1 = 0 ;
36398 int res1 = 0 ;
36399 void *argp2 = 0 ;
36400 int res2 = 0 ;
36401 PyObject * obj0 = 0 ;
36402 PyObject * obj1 = 0 ;
36403 char * kwnames[] = {
36404 (char *) "self",(char *) "cursor", NULL
36405 };
36406
36407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36409 if (!SWIG_IsOK(res1)) {
36410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36411 }
36412 arg1 = reinterpret_cast< wxWindow * >(argp1);
36413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36414 if (!SWIG_IsOK(res2)) {
36415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36416 }
36417 if (!argp2) {
36418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36419 }
36420 arg2 = reinterpret_cast< wxCursor * >(argp2);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 {
36428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36429 }
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 wxCursor result;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 PyObject *swig_obj[1] ;
36443
36444 if (!args) SWIG_fail;
36445 swig_obj[0] = args;
36446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 result = (arg1)->GetCursor();
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 wxFont *arg2 = 0 ;
36468 bool result;
36469 void *argp1 = 0 ;
36470 int res1 = 0 ;
36471 void *argp2 = 0 ;
36472 int res2 = 0 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char * kwnames[] = {
36476 (char *) "self",(char *) "font", NULL
36477 };
36478
36479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36481 if (!SWIG_IsOK(res1)) {
36482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36483 }
36484 arg1 = reinterpret_cast< wxWindow * >(argp1);
36485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36486 if (!SWIG_IsOK(res2)) {
36487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36488 }
36489 if (!argp2) {
36490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36491 }
36492 arg2 = reinterpret_cast< wxFont * >(argp2);
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36496 wxPyEndAllowThreads(__tstate);
36497 if (PyErr_Occurred()) SWIG_fail;
36498 }
36499 {
36500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36501 }
36502 return resultobj;
36503 fail:
36504 return NULL;
36505 }
36506
36507
36508 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36509 PyObject *resultobj = 0;
36510 wxWindow *arg1 = (wxWindow *) 0 ;
36511 wxFont *arg2 = 0 ;
36512 void *argp1 = 0 ;
36513 int res1 = 0 ;
36514 void *argp2 = 0 ;
36515 int res2 = 0 ;
36516 PyObject * obj0 = 0 ;
36517 PyObject * obj1 = 0 ;
36518 char * kwnames[] = {
36519 (char *) "self",(char *) "font", NULL
36520 };
36521
36522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36524 if (!SWIG_IsOK(res1)) {
36525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36526 }
36527 arg1 = reinterpret_cast< wxWindow * >(argp1);
36528 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36529 if (!SWIG_IsOK(res2)) {
36530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36531 }
36532 if (!argp2) {
36533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36534 }
36535 arg2 = reinterpret_cast< wxFont * >(argp2);
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 (arg1)->SetOwnFont((wxFont const &)*arg2);
36539 wxPyEndAllowThreads(__tstate);
36540 if (PyErr_Occurred()) SWIG_fail;
36541 }
36542 resultobj = SWIG_Py_Void();
36543 return resultobj;
36544 fail:
36545 return NULL;
36546 }
36547
36548
36549 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36550 PyObject *resultobj = 0;
36551 wxWindow *arg1 = (wxWindow *) 0 ;
36552 wxFont result;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 PyObject *swig_obj[1] ;
36556
36557 if (!args) SWIG_fail;
36558 swig_obj[0] = args;
36559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 {
36565 PyThreadState* __tstate = wxPyBeginAllowThreads();
36566 result = (arg1)->GetFont();
36567 wxPyEndAllowThreads(__tstate);
36568 if (PyErr_Occurred()) SWIG_fail;
36569 }
36570 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj = 0;
36579 wxWindow *arg1 = (wxWindow *) 0 ;
36580 wxCaret *arg2 = (wxCaret *) 0 ;
36581 void *argp1 = 0 ;
36582 int res1 = 0 ;
36583 int res2 = 0 ;
36584 PyObject * obj0 = 0 ;
36585 PyObject * obj1 = 0 ;
36586 char * kwnames[] = {
36587 (char *) "self",(char *) "caret", NULL
36588 };
36589
36590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36592 if (!SWIG_IsOK(res1)) {
36593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36594 }
36595 arg1 = reinterpret_cast< wxWindow * >(argp1);
36596 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36597 if (!SWIG_IsOK(res2)) {
36598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36599 }
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 (arg1)->SetCaret(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_Py_Void();
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 wxCaret *result = 0 ;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 int result;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 PyObject *swig_obj[1] ;
36648
36649 if (!args) SWIG_fail;
36650 swig_obj[0] = args;
36651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36654 }
36655 arg1 = reinterpret_cast< wxWindow * >(argp1);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 resultobj = SWIG_From_int(static_cast< int >(result));
36663 return resultobj;
36664 fail:
36665 return NULL;
36666 }
36667
36668
36669 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36670 PyObject *resultobj = 0;
36671 wxWindow *arg1 = (wxWindow *) 0 ;
36672 int result;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 PyObject *swig_obj[1] ;
36676
36677 if (!args) SWIG_fail;
36678 swig_obj[0] = args;
36679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36680 if (!SWIG_IsOK(res1)) {
36681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36682 }
36683 arg1 = reinterpret_cast< wxWindow * >(argp1);
36684 {
36685 PyThreadState* __tstate = wxPyBeginAllowThreads();
36686 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36687 wxPyEndAllowThreads(__tstate);
36688 if (PyErr_Occurred()) SWIG_fail;
36689 }
36690 resultobj = SWIG_From_int(static_cast< int >(result));
36691 return resultobj;
36692 fail:
36693 return NULL;
36694 }
36695
36696
36697 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36698 PyObject *resultobj = 0;
36699 wxWindow *arg1 = (wxWindow *) 0 ;
36700 wxString *arg2 = 0 ;
36701 int *arg3 = (int *) 0 ;
36702 int *arg4 = (int *) 0 ;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 bool temp2 = false ;
36706 int temp3 ;
36707 int res3 = SWIG_TMPOBJ ;
36708 int temp4 ;
36709 int res4 = SWIG_TMPOBJ ;
36710 PyObject * obj0 = 0 ;
36711 PyObject * obj1 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "string", NULL
36714 };
36715
36716 arg3 = &temp3;
36717 arg4 = &temp4;
36718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36720 if (!SWIG_IsOK(res1)) {
36721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36722 }
36723 arg1 = reinterpret_cast< wxWindow * >(argp1);
36724 {
36725 arg2 = wxString_in_helper(obj1);
36726 if (arg2 == NULL) SWIG_fail;
36727 temp2 = true;
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 resultobj = SWIG_Py_Void();
36736 if (SWIG_IsTmpObj(res3)) {
36737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36738 } else {
36739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36741 }
36742 if (SWIG_IsTmpObj(res4)) {
36743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36744 } else {
36745 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36747 }
36748 {
36749 if (temp2)
36750 delete arg2;
36751 }
36752 return resultobj;
36753 fail:
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return NULL;
36759 }
36760
36761
36762 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj = 0;
36764 wxWindow *arg1 = (wxWindow *) 0 ;
36765 wxString *arg2 = 0 ;
36766 int *arg3 = (int *) 0 ;
36767 int *arg4 = (int *) 0 ;
36768 int *arg5 = (int *) 0 ;
36769 int *arg6 = (int *) 0 ;
36770 wxFont *arg7 = (wxFont *) NULL ;
36771 void *argp1 = 0 ;
36772 int res1 = 0 ;
36773 bool temp2 = false ;
36774 int temp3 ;
36775 int res3 = SWIG_TMPOBJ ;
36776 int temp4 ;
36777 int res4 = SWIG_TMPOBJ ;
36778 int temp5 ;
36779 int res5 = SWIG_TMPOBJ ;
36780 int temp6 ;
36781 int res6 = SWIG_TMPOBJ ;
36782 void *argp7 = 0 ;
36783 int res7 = 0 ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 PyObject * obj2 = 0 ;
36787 char * kwnames[] = {
36788 (char *) "self",(char *) "string",(char *) "font", NULL
36789 };
36790
36791 arg3 = &temp3;
36792 arg4 = &temp4;
36793 arg5 = &temp5;
36794 arg6 = &temp6;
36795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36797 if (!SWIG_IsOK(res1)) {
36798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36799 }
36800 arg1 = reinterpret_cast< wxWindow * >(argp1);
36801 {
36802 arg2 = wxString_in_helper(obj1);
36803 if (arg2 == NULL) SWIG_fail;
36804 temp2 = true;
36805 }
36806 if (obj2) {
36807 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36808 if (!SWIG_IsOK(res7)) {
36809 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36810 }
36811 arg7 = reinterpret_cast< wxFont * >(argp7);
36812 }
36813 {
36814 PyThreadState* __tstate = wxPyBeginAllowThreads();
36815 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 resultobj = SWIG_Py_Void();
36820 if (SWIG_IsTmpObj(res3)) {
36821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36822 } else {
36823 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36825 }
36826 if (SWIG_IsTmpObj(res4)) {
36827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36828 } else {
36829 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36831 }
36832 if (SWIG_IsTmpObj(res5)) {
36833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36834 } else {
36835 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36837 }
36838 if (SWIG_IsTmpObj(res6)) {
36839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36840 } else {
36841 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36843 }
36844 {
36845 if (temp2)
36846 delete arg2;
36847 }
36848 return resultobj;
36849 fail:
36850 {
36851 if (temp2)
36852 delete arg2;
36853 }
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj = 0;
36860 wxWindow *arg1 = (wxWindow *) 0 ;
36861 int *arg2 = (int *) 0 ;
36862 int *arg3 = (int *) 0 ;
36863 void *argp1 = 0 ;
36864 int res1 = 0 ;
36865 int temp2 ;
36866 int res2 = 0 ;
36867 int temp3 ;
36868 int res3 = 0 ;
36869 PyObject * obj0 = 0 ;
36870 PyObject * obj1 = 0 ;
36871 PyObject * obj2 = 0 ;
36872 char * kwnames[] = {
36873 (char *) "self",(char *) "x",(char *) "y", NULL
36874 };
36875
36876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36878 if (!SWIG_IsOK(res1)) {
36879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36880 }
36881 arg1 = reinterpret_cast< wxWindow * >(argp1);
36882 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36883 int val;
36884 int ecode = SWIG_AsVal_int(obj1, &val);
36885 if (!SWIG_IsOK(ecode)) {
36886 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36887 }
36888 temp2 = static_cast< int >(val);
36889 arg2 = &temp2;
36890 res2 = SWIG_AddTmpMask(ecode);
36891 }
36892 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36893 int val;
36894 int ecode = SWIG_AsVal_int(obj2, &val);
36895 if (!SWIG_IsOK(ecode)) {
36896 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36897 }
36898 temp3 = static_cast< int >(val);
36899 arg3 = &temp3;
36900 res3 = SWIG_AddTmpMask(ecode);
36901 }
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 resultobj = SWIG_Py_Void();
36909 if (SWIG_IsTmpObj(res2)) {
36910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36911 } else {
36912 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36914 }
36915 if (SWIG_IsTmpObj(res3)) {
36916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36917 } else {
36918 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36920 }
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj = 0;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 int *arg2 = (int *) 0 ;
36931 int *arg3 = (int *) 0 ;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 int temp2 ;
36935 int res2 = 0 ;
36936 int temp3 ;
36937 int res3 = 0 ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 PyObject * obj2 = 0 ;
36941 char * kwnames[] = {
36942 (char *) "self",(char *) "x",(char *) "y", NULL
36943 };
36944
36945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36947 if (!SWIG_IsOK(res1)) {
36948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36949 }
36950 arg1 = reinterpret_cast< wxWindow * >(argp1);
36951 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36952 int val;
36953 int ecode = SWIG_AsVal_int(obj1, &val);
36954 if (!SWIG_IsOK(ecode)) {
36955 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36956 }
36957 temp2 = static_cast< int >(val);
36958 arg2 = &temp2;
36959 res2 = SWIG_AddTmpMask(ecode);
36960 }
36961 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36962 int val;
36963 int ecode = SWIG_AsVal_int(obj2, &val);
36964 if (!SWIG_IsOK(ecode)) {
36965 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36966 }
36967 temp3 = static_cast< int >(val);
36968 arg3 = &temp3;
36969 res3 = SWIG_AddTmpMask(ecode);
36970 }
36971 {
36972 PyThreadState* __tstate = wxPyBeginAllowThreads();
36973 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36974 wxPyEndAllowThreads(__tstate);
36975 if (PyErr_Occurred()) SWIG_fail;
36976 }
36977 resultobj = SWIG_Py_Void();
36978 if (SWIG_IsTmpObj(res2)) {
36979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36980 } else {
36981 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36983 }
36984 if (SWIG_IsTmpObj(res3)) {
36985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36986 } else {
36987 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36997 PyObject *resultobj = 0;
36998 wxWindow *arg1 = (wxWindow *) 0 ;
36999 wxPoint *arg2 = 0 ;
37000 wxPoint result;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 wxPoint temp2 ;
37004 PyObject * obj0 = 0 ;
37005 PyObject * obj1 = 0 ;
37006 char * kwnames[] = {
37007 (char *) "self",(char *) "pt", NULL
37008 };
37009
37010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 {
37017 arg2 = &temp2;
37018 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37019 }
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj = 0;
37035 wxWindow *arg1 = (wxWindow *) 0 ;
37036 wxPoint *arg2 = 0 ;
37037 wxPoint result;
37038 void *argp1 = 0 ;
37039 int res1 = 0 ;
37040 wxPoint temp2 ;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 char * kwnames[] = {
37044 (char *) "self",(char *) "pt", NULL
37045 };
37046
37047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37049 if (!SWIG_IsOK(res1)) {
37050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37051 }
37052 arg1 = reinterpret_cast< wxWindow * >(argp1);
37053 {
37054 arg2 = &temp2;
37055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37056 }
37057 {
37058 PyThreadState* __tstate = wxPyBeginAllowThreads();
37059 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37060 wxPyEndAllowThreads(__tstate);
37061 if (PyErr_Occurred()) SWIG_fail;
37062 }
37063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 int arg2 ;
37074 int arg3 ;
37075 wxHitTest result;
37076 void *argp1 = 0 ;
37077 int res1 = 0 ;
37078 int val2 ;
37079 int ecode2 = 0 ;
37080 int val3 ;
37081 int ecode3 = 0 ;
37082 PyObject * obj0 = 0 ;
37083 PyObject * obj1 = 0 ;
37084 PyObject * obj2 = 0 ;
37085 char * kwnames[] = {
37086 (char *) "self",(char *) "x",(char *) "y", NULL
37087 };
37088
37089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37091 if (!SWIG_IsOK(res1)) {
37092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37093 }
37094 arg1 = reinterpret_cast< wxWindow * >(argp1);
37095 ecode2 = SWIG_AsVal_int(obj1, &val2);
37096 if (!SWIG_IsOK(ecode2)) {
37097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37098 }
37099 arg2 = static_cast< int >(val2);
37100 ecode3 = SWIG_AsVal_int(obj2, &val3);
37101 if (!SWIG_IsOK(ecode3)) {
37102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37103 }
37104 arg3 = static_cast< int >(val3);
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 resultobj = SWIG_From_int(static_cast< int >(result));
37112 return resultobj;
37113 fail:
37114 return NULL;
37115 }
37116
37117
37118 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37119 PyObject *resultobj = 0;
37120 wxWindow *arg1 = (wxWindow *) 0 ;
37121 wxPoint *arg2 = 0 ;
37122 wxHitTest result;
37123 void *argp1 = 0 ;
37124 int res1 = 0 ;
37125 wxPoint temp2 ;
37126 PyObject * obj0 = 0 ;
37127 PyObject * obj1 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "pt", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37136 }
37137 arg1 = reinterpret_cast< wxWindow * >(argp1);
37138 {
37139 arg2 = &temp2;
37140 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37141 }
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37145 wxPyEndAllowThreads(__tstate);
37146 if (PyErr_Occurred()) SWIG_fail;
37147 }
37148 resultobj = SWIG_From_int(static_cast< int >(result));
37149 return resultobj;
37150 fail:
37151 return NULL;
37152 }
37153
37154
37155 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37156 PyObject *resultobj = 0;
37157 wxWindow *arg1 = (wxWindow *) 0 ;
37158 long arg2 ;
37159 wxBorder result;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 long val2 ;
37163 int ecode2 = 0 ;
37164
37165 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37169 }
37170 arg1 = reinterpret_cast< wxWindow * >(argp1);
37171 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37172 if (!SWIG_IsOK(ecode2)) {
37173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37174 }
37175 arg2 = static_cast< long >(val2);
37176 {
37177 PyThreadState* __tstate = wxPyBeginAllowThreads();
37178 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37179 wxPyEndAllowThreads(__tstate);
37180 if (PyErr_Occurred()) SWIG_fail;
37181 }
37182 resultobj = SWIG_From_int(static_cast< int >(result));
37183 return resultobj;
37184 fail:
37185 return NULL;
37186 }
37187
37188
37189 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37190 PyObject *resultobj = 0;
37191 wxWindow *arg1 = (wxWindow *) 0 ;
37192 wxBorder result;
37193 void *argp1 = 0 ;
37194 int res1 = 0 ;
37195
37196 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37205 wxPyEndAllowThreads(__tstate);
37206 if (PyErr_Occurred()) SWIG_fail;
37207 }
37208 resultobj = SWIG_From_int(static_cast< int >(result));
37209 return resultobj;
37210 fail:
37211 return NULL;
37212 }
37213
37214
37215 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37216 int argc;
37217 PyObject *argv[3];
37218
37219 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37220 --argc;
37221 if (argc == 1) {
37222 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37223 }
37224 if (argc == 2) {
37225 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37226 }
37227
37228 fail:
37229 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37230 return NULL;
37231 }
37232
37233
37234 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37235 PyObject *resultobj = 0;
37236 wxWindow *arg1 = (wxWindow *) 0 ;
37237 long arg2 = (long) wxUPDATE_UI_NONE ;
37238 void *argp1 = 0 ;
37239 int res1 = 0 ;
37240 long val2 ;
37241 int ecode2 = 0 ;
37242 PyObject * obj0 = 0 ;
37243 PyObject * obj1 = 0 ;
37244 char * kwnames[] = {
37245 (char *) "self",(char *) "flags", NULL
37246 };
37247
37248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37252 }
37253 arg1 = reinterpret_cast< wxWindow * >(argp1);
37254 if (obj1) {
37255 ecode2 = SWIG_AsVal_long(obj1, &val2);
37256 if (!SWIG_IsOK(ecode2)) {
37257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37258 }
37259 arg2 = static_cast< long >(val2);
37260 }
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 (arg1)->UpdateWindowUI(arg2);
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 resultobj = SWIG_Py_Void();
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 wxMenu *arg2 = (wxMenu *) 0 ;
37278 int arg3 = (int) -1 ;
37279 int arg4 = (int) -1 ;
37280 bool result;
37281 void *argp1 = 0 ;
37282 int res1 = 0 ;
37283 void *argp2 = 0 ;
37284 int res2 = 0 ;
37285 int val3 ;
37286 int ecode3 = 0 ;
37287 int val4 ;
37288 int ecode4 = 0 ;
37289 PyObject * obj0 = 0 ;
37290 PyObject * obj1 = 0 ;
37291 PyObject * obj2 = 0 ;
37292 PyObject * obj3 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37304 if (!SWIG_IsOK(res2)) {
37305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37306 }
37307 arg2 = reinterpret_cast< wxMenu * >(argp2);
37308 if (obj2) {
37309 ecode3 = SWIG_AsVal_int(obj2, &val3);
37310 if (!SWIG_IsOK(ecode3)) {
37311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37312 }
37313 arg3 = static_cast< int >(val3);
37314 }
37315 if (obj3) {
37316 ecode4 = SWIG_AsVal_int(obj3, &val4);
37317 if (!SWIG_IsOK(ecode4)) {
37318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37319 }
37320 arg4 = static_cast< int >(val4);
37321 }
37322 {
37323 PyThreadState* __tstate = wxPyBeginAllowThreads();
37324 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 {
37329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37330 }
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj = 0;
37339 wxWindow *arg1 = (wxWindow *) 0 ;
37340 wxMenu *arg2 = (wxMenu *) 0 ;
37341 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37342 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37343 bool result;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 void *argp2 = 0 ;
37347 int res2 = 0 ;
37348 wxPoint temp3 ;
37349 PyObject * obj0 = 0 ;
37350 PyObject * obj1 = 0 ;
37351 PyObject * obj2 = 0 ;
37352 char * kwnames[] = {
37353 (char *) "self",(char *) "menu",(char *) "pos", NULL
37354 };
37355
37356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37358 if (!SWIG_IsOK(res1)) {
37359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37360 }
37361 arg1 = reinterpret_cast< wxWindow * >(argp1);
37362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37363 if (!SWIG_IsOK(res2)) {
37364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37365 }
37366 arg2 = reinterpret_cast< wxMenu * >(argp2);
37367 if (obj2) {
37368 {
37369 arg3 = &temp3;
37370 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37371 }
37372 }
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37376 wxPyEndAllowThreads(__tstate);
37377 if (PyErr_Occurred()) SWIG_fail;
37378 }
37379 {
37380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37381 }
37382 return resultobj;
37383 fail:
37384 return NULL;
37385 }
37386
37387
37388 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37389 PyObject *resultobj = 0;
37390 wxWindow *arg1 = (wxWindow *) 0 ;
37391 bool result;
37392 void *argp1 = 0 ;
37393 int res1 = 0 ;
37394 PyObject *swig_obj[1] ;
37395
37396 if (!args) SWIG_fail;
37397 swig_obj[0] = args;
37398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37399 if (!SWIG_IsOK(res1)) {
37400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37401 }
37402 arg1 = reinterpret_cast< wxWindow * >(argp1);
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 {
37410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37411 }
37412 return resultobj;
37413 fail:
37414 return NULL;
37415 }
37416
37417
37418 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37419 PyObject *resultobj = 0;
37420 wxWindow *arg1 = (wxWindow *) 0 ;
37421 long result;
37422 void *argp1 = 0 ;
37423 int res1 = 0 ;
37424 PyObject *swig_obj[1] ;
37425
37426 if (!args) SWIG_fail;
37427 swig_obj[0] = args;
37428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37429 if (!SWIG_IsOK(res1)) {
37430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37431 }
37432 arg1 = reinterpret_cast< wxWindow * >(argp1);
37433 {
37434 PyThreadState* __tstate = wxPyBeginAllowThreads();
37435 result = (long)wxWindow_GetHandle(arg1);
37436 wxPyEndAllowThreads(__tstate);
37437 if (PyErr_Occurred()) SWIG_fail;
37438 }
37439 resultobj = SWIG_From_long(static_cast< long >(result));
37440 return resultobj;
37441 fail:
37442 return NULL;
37443 }
37444
37445
37446 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37447 PyObject *resultobj = 0;
37448 wxWindow *arg1 = (wxWindow *) 0 ;
37449 long arg2 ;
37450 void *argp1 = 0 ;
37451 int res1 = 0 ;
37452 long val2 ;
37453 int ecode2 = 0 ;
37454 PyObject * obj0 = 0 ;
37455 PyObject * obj1 = 0 ;
37456 char * kwnames[] = {
37457 (char *) "self",(char *) "handle", NULL
37458 };
37459
37460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37462 if (!SWIG_IsOK(res1)) {
37463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37464 }
37465 arg1 = reinterpret_cast< wxWindow * >(argp1);
37466 ecode2 = SWIG_AsVal_long(obj1, &val2);
37467 if (!SWIG_IsOK(ecode2)) {
37468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37469 }
37470 arg2 = static_cast< long >(val2);
37471 {
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 wxWindow_AssociateHandle(arg1,arg2);
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 resultobj = SWIG_Py_Void();
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37485 PyObject *resultobj = 0;
37486 wxWindow *arg1 = (wxWindow *) 0 ;
37487 void *argp1 = 0 ;
37488 int res1 = 0 ;
37489 PyObject *swig_obj[1] ;
37490
37491 if (!args) SWIG_fail;
37492 swig_obj[0] = args;
37493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37494 if (!SWIG_IsOK(res1)) {
37495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37496 }
37497 arg1 = reinterpret_cast< wxWindow * >(argp1);
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 (arg1)->DissociateHandle();
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 resultobj = SWIG_Py_Void();
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj = 0;
37513 wxWindow *arg1 = (wxWindow *) 0 ;
37514 wxPaintEvent *arg2 = 0 ;
37515 void *argp1 = 0 ;
37516 int res1 = 0 ;
37517 void *argp2 = 0 ;
37518 int res2 = 0 ;
37519 PyObject * obj0 = 0 ;
37520 PyObject * obj1 = 0 ;
37521 char * kwnames[] = {
37522 (char *) "self",(char *) "event", NULL
37523 };
37524
37525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
37526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37527 if (!SWIG_IsOK(res1)) {
37528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
37529 }
37530 arg1 = reinterpret_cast< wxWindow * >(argp1);
37531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
37532 if (!SWIG_IsOK(res2)) {
37533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37534 }
37535 if (!argp2) {
37536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37537 }
37538 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 (arg1)->OnPaint(*arg2);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_Py_Void();
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 int arg2 ;
37556 bool result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 int val2 ;
37560 int ecode2 = 0 ;
37561 PyObject * obj0 = 0 ;
37562 PyObject * obj1 = 0 ;
37563 char * kwnames[] = {
37564 (char *) "self",(char *) "orient", NULL
37565 };
37566
37567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37569 if (!SWIG_IsOK(res1)) {
37570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37571 }
37572 arg1 = reinterpret_cast< wxWindow * >(argp1);
37573 ecode2 = SWIG_AsVal_int(obj1, &val2);
37574 if (!SWIG_IsOK(ecode2)) {
37575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37576 }
37577 arg2 = static_cast< int >(val2);
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 {
37585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37586 }
37587 return resultobj;
37588 fail:
37589 return NULL;
37590 }
37591
37592
37593 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj = 0;
37595 wxWindow *arg1 = (wxWindow *) 0 ;
37596 int arg2 ;
37597 int arg3 ;
37598 int arg4 ;
37599 int arg5 ;
37600 bool arg6 = (bool) true ;
37601 void *argp1 = 0 ;
37602 int res1 = 0 ;
37603 int val2 ;
37604 int ecode2 = 0 ;
37605 int val3 ;
37606 int ecode3 = 0 ;
37607 int val4 ;
37608 int ecode4 = 0 ;
37609 int val5 ;
37610 int ecode5 = 0 ;
37611 bool val6 ;
37612 int ecode6 = 0 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 PyObject * obj2 = 0 ;
37616 PyObject * obj3 = 0 ;
37617 PyObject * obj4 = 0 ;
37618 PyObject * obj5 = 0 ;
37619 char * kwnames[] = {
37620 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37621 };
37622
37623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37625 if (!SWIG_IsOK(res1)) {
37626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37627 }
37628 arg1 = reinterpret_cast< wxWindow * >(argp1);
37629 ecode2 = SWIG_AsVal_int(obj1, &val2);
37630 if (!SWIG_IsOK(ecode2)) {
37631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37632 }
37633 arg2 = static_cast< int >(val2);
37634 ecode3 = SWIG_AsVal_int(obj2, &val3);
37635 if (!SWIG_IsOK(ecode3)) {
37636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37637 }
37638 arg3 = static_cast< int >(val3);
37639 ecode4 = SWIG_AsVal_int(obj3, &val4);
37640 if (!SWIG_IsOK(ecode4)) {
37641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37642 }
37643 arg4 = static_cast< int >(val4);
37644 ecode5 = SWIG_AsVal_int(obj4, &val5);
37645 if (!SWIG_IsOK(ecode5)) {
37646 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37647 }
37648 arg5 = static_cast< int >(val5);
37649 if (obj5) {
37650 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37651 if (!SWIG_IsOK(ecode6)) {
37652 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37653 }
37654 arg6 = static_cast< bool >(val6);
37655 }
37656 {
37657 PyThreadState* __tstate = wxPyBeginAllowThreads();
37658 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37659 wxPyEndAllowThreads(__tstate);
37660 if (PyErr_Occurred()) SWIG_fail;
37661 }
37662 resultobj = SWIG_Py_Void();
37663 return resultobj;
37664 fail:
37665 return NULL;
37666 }
37667
37668
37669 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37670 PyObject *resultobj = 0;
37671 wxWindow *arg1 = (wxWindow *) 0 ;
37672 int arg2 ;
37673 int arg3 ;
37674 bool arg4 = (bool) true ;
37675 void *argp1 = 0 ;
37676 int res1 = 0 ;
37677 int val2 ;
37678 int ecode2 = 0 ;
37679 int val3 ;
37680 int ecode3 = 0 ;
37681 bool val4 ;
37682 int ecode4 = 0 ;
37683 PyObject * obj0 = 0 ;
37684 PyObject * obj1 = 0 ;
37685 PyObject * obj2 = 0 ;
37686 PyObject * obj3 = 0 ;
37687 char * kwnames[] = {
37688 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37689 };
37690
37691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37693 if (!SWIG_IsOK(res1)) {
37694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37695 }
37696 arg1 = reinterpret_cast< wxWindow * >(argp1);
37697 ecode2 = SWIG_AsVal_int(obj1, &val2);
37698 if (!SWIG_IsOK(ecode2)) {
37699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37700 }
37701 arg2 = static_cast< int >(val2);
37702 ecode3 = SWIG_AsVal_int(obj2, &val3);
37703 if (!SWIG_IsOK(ecode3)) {
37704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37705 }
37706 arg3 = static_cast< int >(val3);
37707 if (obj3) {
37708 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37709 if (!SWIG_IsOK(ecode4)) {
37710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37711 }
37712 arg4 = static_cast< bool >(val4);
37713 }
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 (arg1)->SetScrollPos(arg2,arg3,arg4);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 resultobj = SWIG_Py_Void();
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxWindow *arg1 = (wxWindow *) 0 ;
37730 int arg2 ;
37731 int result;
37732 void *argp1 = 0 ;
37733 int res1 = 0 ;
37734 int val2 ;
37735 int ecode2 = 0 ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char * kwnames[] = {
37739 (char *) "self",(char *) "orientation", NULL
37740 };
37741
37742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37744 if (!SWIG_IsOK(res1)) {
37745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37746 }
37747 arg1 = reinterpret_cast< wxWindow * >(argp1);
37748 ecode2 = SWIG_AsVal_int(obj1, &val2);
37749 if (!SWIG_IsOK(ecode2)) {
37750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37751 }
37752 arg2 = static_cast< int >(val2);
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = SWIG_From_int(static_cast< int >(result));
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 int arg2 ;
37770 int result;
37771 void *argp1 = 0 ;
37772 int res1 = 0 ;
37773 int val2 ;
37774 int ecode2 = 0 ;
37775 PyObject * obj0 = 0 ;
37776 PyObject * obj1 = 0 ;
37777 char * kwnames[] = {
37778 (char *) "self",(char *) "orientation", NULL
37779 };
37780
37781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37783 if (!SWIG_IsOK(res1)) {
37784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37785 }
37786 arg1 = reinterpret_cast< wxWindow * >(argp1);
37787 ecode2 = SWIG_AsVal_int(obj1, &val2);
37788 if (!SWIG_IsOK(ecode2)) {
37789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37790 }
37791 arg2 = static_cast< int >(val2);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 resultobj = SWIG_From_int(static_cast< int >(result));
37799 return resultobj;
37800 fail:
37801 return NULL;
37802 }
37803
37804
37805 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37806 PyObject *resultobj = 0;
37807 wxWindow *arg1 = (wxWindow *) 0 ;
37808 int arg2 ;
37809 int result;
37810 void *argp1 = 0 ;
37811 int res1 = 0 ;
37812 int val2 ;
37813 int ecode2 = 0 ;
37814 PyObject * obj0 = 0 ;
37815 PyObject * obj1 = 0 ;
37816 char * kwnames[] = {
37817 (char *) "self",(char *) "orientation", NULL
37818 };
37819
37820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37822 if (!SWIG_IsOK(res1)) {
37823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37824 }
37825 arg1 = reinterpret_cast< wxWindow * >(argp1);
37826 ecode2 = SWIG_AsVal_int(obj1, &val2);
37827 if (!SWIG_IsOK(ecode2)) {
37828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37829 }
37830 arg2 = static_cast< int >(val2);
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 resultobj = SWIG_From_int(static_cast< int >(result));
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj = 0;
37846 wxWindow *arg1 = (wxWindow *) 0 ;
37847 int arg2 ;
37848 int arg3 ;
37849 wxRect *arg4 = (wxRect *) NULL ;
37850 void *argp1 = 0 ;
37851 int res1 = 0 ;
37852 int val2 ;
37853 int ecode2 = 0 ;
37854 int val3 ;
37855 int ecode3 = 0 ;
37856 void *argp4 = 0 ;
37857 int res4 = 0 ;
37858 PyObject * obj0 = 0 ;
37859 PyObject * obj1 = 0 ;
37860 PyObject * obj2 = 0 ;
37861 PyObject * obj3 = 0 ;
37862 char * kwnames[] = {
37863 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37864 };
37865
37866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 ecode2 = SWIG_AsVal_int(obj1, &val2);
37873 if (!SWIG_IsOK(ecode2)) {
37874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37875 }
37876 arg2 = static_cast< int >(val2);
37877 ecode3 = SWIG_AsVal_int(obj2, &val3);
37878 if (!SWIG_IsOK(ecode3)) {
37879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37880 }
37881 arg3 = static_cast< int >(val3);
37882 if (obj3) {
37883 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37884 if (!SWIG_IsOK(res4)) {
37885 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37886 }
37887 arg4 = reinterpret_cast< wxRect * >(argp4);
37888 }
37889 {
37890 PyThreadState* __tstate = wxPyBeginAllowThreads();
37891 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37892 wxPyEndAllowThreads(__tstate);
37893 if (PyErr_Occurred()) SWIG_fail;
37894 }
37895 resultobj = SWIG_Py_Void();
37896 return resultobj;
37897 fail:
37898 return NULL;
37899 }
37900
37901
37902 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37903 PyObject *resultobj = 0;
37904 wxWindow *arg1 = (wxWindow *) 0 ;
37905 int arg2 ;
37906 bool result;
37907 void *argp1 = 0 ;
37908 int res1 = 0 ;
37909 int val2 ;
37910 int ecode2 = 0 ;
37911 PyObject * obj0 = 0 ;
37912 PyObject * obj1 = 0 ;
37913 char * kwnames[] = {
37914 (char *) "self",(char *) "lines", NULL
37915 };
37916
37917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37921 }
37922 arg1 = reinterpret_cast< wxWindow * >(argp1);
37923 ecode2 = SWIG_AsVal_int(obj1, &val2);
37924 if (!SWIG_IsOK(ecode2)) {
37925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37926 }
37927 arg2 = static_cast< int >(val2);
37928 {
37929 PyThreadState* __tstate = wxPyBeginAllowThreads();
37930 result = (bool)(arg1)->ScrollLines(arg2);
37931 wxPyEndAllowThreads(__tstate);
37932 if (PyErr_Occurred()) SWIG_fail;
37933 }
37934 {
37935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37936 }
37937 return resultobj;
37938 fail:
37939 return NULL;
37940 }
37941
37942
37943 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37944 PyObject *resultobj = 0;
37945 wxWindow *arg1 = (wxWindow *) 0 ;
37946 int arg2 ;
37947 bool result;
37948 void *argp1 = 0 ;
37949 int res1 = 0 ;
37950 int val2 ;
37951 int ecode2 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 char * kwnames[] = {
37955 (char *) "self",(char *) "pages", NULL
37956 };
37957
37958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37960 if (!SWIG_IsOK(res1)) {
37961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37962 }
37963 arg1 = reinterpret_cast< wxWindow * >(argp1);
37964 ecode2 = SWIG_AsVal_int(obj1, &val2);
37965 if (!SWIG_IsOK(ecode2)) {
37966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37967 }
37968 arg2 = static_cast< int >(val2);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (bool)(arg1)->ScrollPages(arg2);
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37985 PyObject *resultobj = 0;
37986 wxWindow *arg1 = (wxWindow *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 PyObject *swig_obj[1] ;
37991
37992 if (!args) SWIG_fail;
37993 swig_obj[0] = args;
37994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37997 }
37998 arg1 = reinterpret_cast< wxWindow * >(argp1);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (bool)(arg1)->LineUp();
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxWindow *arg1 = (wxWindow *) 0 ;
38017 bool result;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 PyObject *swig_obj[1] ;
38021
38022 if (!args) SWIG_fail;
38023 swig_obj[0] = args;
38024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38025 if (!SWIG_IsOK(res1)) {
38026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38027 }
38028 arg1 = reinterpret_cast< wxWindow * >(argp1);
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (bool)(arg1)->LineDown();
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38045 PyObject *resultobj = 0;
38046 wxWindow *arg1 = (wxWindow *) 0 ;
38047 bool result;
38048 void *argp1 = 0 ;
38049 int res1 = 0 ;
38050 PyObject *swig_obj[1] ;
38051
38052 if (!args) SWIG_fail;
38053 swig_obj[0] = args;
38054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38055 if (!SWIG_IsOK(res1)) {
38056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38057 }
38058 arg1 = reinterpret_cast< wxWindow * >(argp1);
38059 {
38060 PyThreadState* __tstate = wxPyBeginAllowThreads();
38061 result = (bool)(arg1)->PageUp();
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38075 PyObject *resultobj = 0;
38076 wxWindow *arg1 = (wxWindow *) 0 ;
38077 bool result;
38078 void *argp1 = 0 ;
38079 int res1 = 0 ;
38080 PyObject *swig_obj[1] ;
38081
38082 if (!args) SWIG_fail;
38083 swig_obj[0] = args;
38084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38085 if (!SWIG_IsOK(res1)) {
38086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38087 }
38088 arg1 = reinterpret_cast< wxWindow * >(argp1);
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 result = (bool)(arg1)->PageDown();
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 {
38096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38097 }
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj = 0;
38106 wxWindow *arg1 = (wxWindow *) 0 ;
38107 wxString *arg2 = 0 ;
38108 void *argp1 = 0 ;
38109 int res1 = 0 ;
38110 bool temp2 = false ;
38111 PyObject * obj0 = 0 ;
38112 PyObject * obj1 = 0 ;
38113 char * kwnames[] = {
38114 (char *) "self",(char *) "text", NULL
38115 };
38116
38117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38119 if (!SWIG_IsOK(res1)) {
38120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38121 }
38122 arg1 = reinterpret_cast< wxWindow * >(argp1);
38123 {
38124 arg2 = wxString_in_helper(obj1);
38125 if (arg2 == NULL) SWIG_fail;
38126 temp2 = true;
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 (arg1)->SetHelpText((wxString const &)*arg2);
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 resultobj = SWIG_Py_Void();
38135 {
38136 if (temp2)
38137 delete arg2;
38138 }
38139 return resultobj;
38140 fail:
38141 {
38142 if (temp2)
38143 delete arg2;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj = 0;
38151 wxWindow *arg1 = (wxWindow *) 0 ;
38152 wxString *arg2 = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 bool temp2 = false ;
38156 PyObject * obj0 = 0 ;
38157 PyObject * obj1 = 0 ;
38158 char * kwnames[] = {
38159 (char *) "self",(char *) "text", NULL
38160 };
38161
38162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38164 if (!SWIG_IsOK(res1)) {
38165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38166 }
38167 arg1 = reinterpret_cast< wxWindow * >(argp1);
38168 {
38169 arg2 = wxString_in_helper(obj1);
38170 if (arg2 == NULL) SWIG_fail;
38171 temp2 = true;
38172 }
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38176 wxPyEndAllowThreads(__tstate);
38177 if (PyErr_Occurred()) SWIG_fail;
38178 }
38179 resultobj = SWIG_Py_Void();
38180 {
38181 if (temp2)
38182 delete arg2;
38183 }
38184 return resultobj;
38185 fail:
38186 {
38187 if (temp2)
38188 delete arg2;
38189 }
38190 return NULL;
38191 }
38192
38193
38194 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = 0;
38196 wxWindow *arg1 = (wxWindow *) 0 ;
38197 wxPoint *arg2 = 0 ;
38198 wxHelpEvent::Origin arg3 ;
38199 wxString result;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 wxPoint temp2 ;
38203 void *argp3 ;
38204 int res3 = 0 ;
38205 PyObject * obj0 = 0 ;
38206 PyObject * obj1 = 0 ;
38207 PyObject * obj2 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "pt",(char *) "origin", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 arg2 = &temp2;
38220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38221 }
38222 {
38223 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38224 if (!SWIG_IsOK(res3)) {
38225 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38226 }
38227 if (!argp3) {
38228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38229 } else {
38230 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38231 arg3 = *temp;
38232 if (SWIG_IsNewObj(res3)) delete temp;
38233 }
38234 }
38235 {
38236 PyThreadState* __tstate = wxPyBeginAllowThreads();
38237 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38238 wxPyEndAllowThreads(__tstate);
38239 if (PyErr_Occurred()) SWIG_fail;
38240 }
38241 {
38242 #if wxUSE_UNICODE
38243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38244 #else
38245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38246 #endif
38247 }
38248 return resultobj;
38249 fail:
38250 return NULL;
38251 }
38252
38253
38254 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38255 PyObject *resultobj = 0;
38256 wxWindow *arg1 = (wxWindow *) 0 ;
38257 wxString result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 PyObject *swig_obj[1] ;
38261
38262 if (!args) SWIG_fail;
38263 swig_obj[0] = args;
38264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38267 }
38268 arg1 = reinterpret_cast< wxWindow * >(argp1);
38269 {
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = ((wxWindow const *)arg1)->GetHelpText();
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 {
38276 #if wxUSE_UNICODE
38277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38278 #else
38279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38280 #endif
38281 }
38282 return resultobj;
38283 fail:
38284 return NULL;
38285 }
38286
38287
38288 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38289 PyObject *resultobj = 0;
38290 wxWindow *arg1 = (wxWindow *) 0 ;
38291 wxString *arg2 = 0 ;
38292 void *argp1 = 0 ;
38293 int res1 = 0 ;
38294 bool temp2 = false ;
38295 PyObject * obj0 = 0 ;
38296 PyObject * obj1 = 0 ;
38297 char * kwnames[] = {
38298 (char *) "self",(char *) "tip", NULL
38299 };
38300
38301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38303 if (!SWIG_IsOK(res1)) {
38304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38305 }
38306 arg1 = reinterpret_cast< wxWindow * >(argp1);
38307 {
38308 arg2 = wxString_in_helper(obj1);
38309 if (arg2 == NULL) SWIG_fail;
38310 temp2 = true;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 (arg1)->SetToolTip((wxString const &)*arg2);
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 resultobj = SWIG_Py_Void();
38319 {
38320 if (temp2)
38321 delete arg2;
38322 }
38323 return resultobj;
38324 fail:
38325 {
38326 if (temp2)
38327 delete arg2;
38328 }
38329 return NULL;
38330 }
38331
38332
38333 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38334 PyObject *resultobj = 0;
38335 wxWindow *arg1 = (wxWindow *) 0 ;
38336 wxToolTip *arg2 = (wxToolTip *) 0 ;
38337 void *argp1 = 0 ;
38338 int res1 = 0 ;
38339 int res2 = 0 ;
38340 PyObject * obj0 = 0 ;
38341 PyObject * obj1 = 0 ;
38342 char * kwnames[] = {
38343 (char *) "self",(char *) "tip", NULL
38344 };
38345
38346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38348 if (!SWIG_IsOK(res1)) {
38349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38350 }
38351 arg1 = reinterpret_cast< wxWindow * >(argp1);
38352 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38353 if (!SWIG_IsOK(res2)) {
38354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 (arg1)->SetToolTip(arg2);
38359 wxPyEndAllowThreads(__tstate);
38360 if (PyErr_Occurred()) SWIG_fail;
38361 }
38362 resultobj = SWIG_Py_Void();
38363 return resultobj;
38364 fail:
38365 return NULL;
38366 }
38367
38368
38369 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38370 PyObject *resultobj = 0;
38371 wxWindow *arg1 = (wxWindow *) 0 ;
38372 wxToolTip *result = 0 ;
38373 void *argp1 = 0 ;
38374 int res1 = 0 ;
38375 PyObject *swig_obj[1] ;
38376
38377 if (!args) SWIG_fail;
38378 swig_obj[0] = args;
38379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38380 if (!SWIG_IsOK(res1)) {
38381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38382 }
38383 arg1 = reinterpret_cast< wxWindow * >(argp1);
38384 {
38385 PyThreadState* __tstate = wxPyBeginAllowThreads();
38386 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38387 wxPyEndAllowThreads(__tstate);
38388 if (PyErr_Occurred()) SWIG_fail;
38389 }
38390 {
38391 resultobj = wxPyMake_wxObject(result, (bool)0);
38392 }
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38400 PyObject *resultobj = 0;
38401 wxWindow *arg1 = (wxWindow *) 0 ;
38402 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38403 void *argp1 = 0 ;
38404 int res1 = 0 ;
38405 int res2 = 0 ;
38406 PyObject * obj0 = 0 ;
38407 PyObject * obj1 = 0 ;
38408 char * kwnames[] = {
38409 (char *) "self",(char *) "dropTarget", NULL
38410 };
38411
38412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38414 if (!SWIG_IsOK(res1)) {
38415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38416 }
38417 arg1 = reinterpret_cast< wxWindow * >(argp1);
38418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38419 if (!SWIG_IsOK(res2)) {
38420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38421 }
38422 {
38423 PyThreadState* __tstate = wxPyBeginAllowThreads();
38424 (arg1)->SetDropTarget(arg2);
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 resultobj = SWIG_Py_Void();
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38436 PyObject *resultobj = 0;
38437 wxWindow *arg1 = (wxWindow *) 0 ;
38438 wxPyDropTarget *result = 0 ;
38439 void *argp1 = 0 ;
38440 int res1 = 0 ;
38441 PyObject *swig_obj[1] ;
38442
38443 if (!args) SWIG_fail;
38444 swig_obj[0] = args;
38445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38446 if (!SWIG_IsOK(res1)) {
38447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38448 }
38449 arg1 = reinterpret_cast< wxWindow * >(argp1);
38450 {
38451 PyThreadState* __tstate = wxPyBeginAllowThreads();
38452 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38453 wxPyEndAllowThreads(__tstate);
38454 if (PyErr_Occurred()) SWIG_fail;
38455 }
38456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38457 return resultobj;
38458 fail:
38459 return NULL;
38460 }
38461
38462
38463 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38464 PyObject *resultobj = 0;
38465 wxWindow *arg1 = (wxWindow *) 0 ;
38466 bool arg2 ;
38467 void *argp1 = 0 ;
38468 int res1 = 0 ;
38469 bool val2 ;
38470 int ecode2 = 0 ;
38471 PyObject * obj0 = 0 ;
38472 PyObject * obj1 = 0 ;
38473 char * kwnames[] = {
38474 (char *) "self",(char *) "accept", NULL
38475 };
38476
38477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38479 if (!SWIG_IsOK(res1)) {
38480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38481 }
38482 arg1 = reinterpret_cast< wxWindow * >(argp1);
38483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38484 if (!SWIG_IsOK(ecode2)) {
38485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38486 }
38487 arg2 = static_cast< bool >(val2);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 (arg1)->DragAcceptFiles(arg2);
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_Py_Void();
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj = 0;
38503 wxWindow *arg1 = (wxWindow *) 0 ;
38504 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38505 void *argp1 = 0 ;
38506 int res1 = 0 ;
38507 int res2 = 0 ;
38508 PyObject * obj0 = 0 ;
38509 PyObject * obj1 = 0 ;
38510 char * kwnames[] = {
38511 (char *) "self",(char *) "constraints", NULL
38512 };
38513
38514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38516 if (!SWIG_IsOK(res1)) {
38517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38518 }
38519 arg1 = reinterpret_cast< wxWindow * >(argp1);
38520 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38521 if (!SWIG_IsOK(res2)) {
38522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38523 }
38524 {
38525 PyThreadState* __tstate = wxPyBeginAllowThreads();
38526 (arg1)->SetConstraints(arg2);
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 resultobj = SWIG_Py_Void();
38531 return resultobj;
38532 fail:
38533 return NULL;
38534 }
38535
38536
38537 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38538 PyObject *resultobj = 0;
38539 wxWindow *arg1 = (wxWindow *) 0 ;
38540 wxLayoutConstraints *result = 0 ;
38541 void *argp1 = 0 ;
38542 int res1 = 0 ;
38543 PyObject *swig_obj[1] ;
38544
38545 if (!args) SWIG_fail;
38546 swig_obj[0] = args;
38547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38548 if (!SWIG_IsOK(res1)) {
38549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38550 }
38551 arg1 = reinterpret_cast< wxWindow * >(argp1);
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38559 return resultobj;
38560 fail:
38561 return NULL;
38562 }
38563
38564
38565 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38566 PyObject *resultobj = 0;
38567 wxWindow *arg1 = (wxWindow *) 0 ;
38568 bool arg2 ;
38569 void *argp1 = 0 ;
38570 int res1 = 0 ;
38571 bool val2 ;
38572 int ecode2 = 0 ;
38573 PyObject * obj0 = 0 ;
38574 PyObject * obj1 = 0 ;
38575 char * kwnames[] = {
38576 (char *) "self",(char *) "autoLayout", NULL
38577 };
38578
38579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38581 if (!SWIG_IsOK(res1)) {
38582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38583 }
38584 arg1 = reinterpret_cast< wxWindow * >(argp1);
38585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38586 if (!SWIG_IsOK(ecode2)) {
38587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38588 }
38589 arg2 = static_cast< bool >(val2);
38590 {
38591 PyThreadState* __tstate = wxPyBeginAllowThreads();
38592 (arg1)->SetAutoLayout(arg2);
38593 wxPyEndAllowThreads(__tstate);
38594 if (PyErr_Occurred()) SWIG_fail;
38595 }
38596 resultobj = SWIG_Py_Void();
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38604 PyObject *resultobj = 0;
38605 wxWindow *arg1 = (wxWindow *) 0 ;
38606 bool result;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 PyObject *swig_obj[1] ;
38610
38611 if (!args) SWIG_fail;
38612 swig_obj[0] = args;
38613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38634 PyObject *resultobj = 0;
38635 wxWindow *arg1 = (wxWindow *) 0 ;
38636 bool result;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 PyObject *swig_obj[1] ;
38640
38641 if (!args) SWIG_fail;
38642 swig_obj[0] = args;
38643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38646 }
38647 arg1 = reinterpret_cast< wxWindow * >(argp1);
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 result = (bool)(arg1)->Layout();
38651 wxPyEndAllowThreads(__tstate);
38652 if (PyErr_Occurred()) SWIG_fail;
38653 }
38654 {
38655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38656 }
38657 return resultobj;
38658 fail:
38659 return NULL;
38660 }
38661
38662
38663 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj = 0;
38665 wxWindow *arg1 = (wxWindow *) 0 ;
38666 wxSizer *arg2 = (wxSizer *) 0 ;
38667 bool arg3 = (bool) true ;
38668 void *argp1 = 0 ;
38669 int res1 = 0 ;
38670 int res2 = 0 ;
38671 bool val3 ;
38672 int ecode3 = 0 ;
38673 PyObject * obj0 = 0 ;
38674 PyObject * obj1 = 0 ;
38675 PyObject * obj2 = 0 ;
38676 char * kwnames[] = {
38677 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38678 };
38679
38680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38684 }
38685 arg1 = reinterpret_cast< wxWindow * >(argp1);
38686 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38687 if (!SWIG_IsOK(res2)) {
38688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38689 }
38690 if (obj2) {
38691 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38692 if (!SWIG_IsOK(ecode3)) {
38693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38694 }
38695 arg3 = static_cast< bool >(val3);
38696 }
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 (arg1)->SetSizer(arg2,arg3);
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_Py_Void();
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 wxSizer *arg2 = (wxSizer *) 0 ;
38714 bool arg3 = (bool) true ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 int res2 = 0 ;
38718 bool val3 ;
38719 int ecode3 = 0 ;
38720 PyObject * obj0 = 0 ;
38721 PyObject * obj1 = 0 ;
38722 PyObject * obj2 = 0 ;
38723 char * kwnames[] = {
38724 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38725 };
38726
38727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38729 if (!SWIG_IsOK(res1)) {
38730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38731 }
38732 arg1 = reinterpret_cast< wxWindow * >(argp1);
38733 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38734 if (!SWIG_IsOK(res2)) {
38735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38736 }
38737 if (obj2) {
38738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38739 if (!SWIG_IsOK(ecode3)) {
38740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38741 }
38742 arg3 = static_cast< bool >(val3);
38743 }
38744 {
38745 PyThreadState* __tstate = wxPyBeginAllowThreads();
38746 (arg1)->SetSizerAndFit(arg2,arg3);
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 resultobj = SWIG_Py_Void();
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38758 PyObject *resultobj = 0;
38759 wxWindow *arg1 = (wxWindow *) 0 ;
38760 wxSizer *result = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 PyObject *swig_obj[1] ;
38764
38765 if (!args) SWIG_fail;
38766 swig_obj[0] = args;
38767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38768 if (!SWIG_IsOK(res1)) {
38769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38770 }
38771 arg1 = reinterpret_cast< wxWindow * >(argp1);
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 resultobj = wxPyMake_wxObject(result, (bool)0);
38780 }
38781 return resultobj;
38782 fail:
38783 return NULL;
38784 }
38785
38786
38787 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38788 PyObject *resultobj = 0;
38789 wxWindow *arg1 = (wxWindow *) 0 ;
38790 wxSizer *arg2 = (wxSizer *) 0 ;
38791 void *argp1 = 0 ;
38792 int res1 = 0 ;
38793 void *argp2 = 0 ;
38794 int res2 = 0 ;
38795 PyObject * obj0 = 0 ;
38796 PyObject * obj1 = 0 ;
38797 char * kwnames[] = {
38798 (char *) "self",(char *) "sizer", NULL
38799 };
38800
38801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38803 if (!SWIG_IsOK(res1)) {
38804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38805 }
38806 arg1 = reinterpret_cast< wxWindow * >(argp1);
38807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38808 if (!SWIG_IsOK(res2)) {
38809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38810 }
38811 arg2 = reinterpret_cast< wxSizer * >(argp2);
38812 {
38813 PyThreadState* __tstate = wxPyBeginAllowThreads();
38814 (arg1)->SetContainingSizer(arg2);
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 resultobj = SWIG_Py_Void();
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *resultobj = 0;
38827 wxWindow *arg1 = (wxWindow *) 0 ;
38828 wxSizer *result = 0 ;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 PyObject *swig_obj[1] ;
38832
38833 if (!args) SWIG_fail;
38834 swig_obj[0] = args;
38835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 {
38847 resultobj = wxPyMake_wxObject(result, (bool)0);
38848 }
38849 return resultobj;
38850 fail:
38851 return NULL;
38852 }
38853
38854
38855 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38856 PyObject *resultobj = 0;
38857 wxWindow *arg1 = (wxWindow *) 0 ;
38858 void *argp1 = 0 ;
38859 int res1 = 0 ;
38860 PyObject *swig_obj[1] ;
38861
38862 if (!args) SWIG_fail;
38863 swig_obj[0] = args;
38864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38865 if (!SWIG_IsOK(res1)) {
38866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38867 }
38868 arg1 = reinterpret_cast< wxWindow * >(argp1);
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 (arg1)->InheritAttributes();
38872 wxPyEndAllowThreads(__tstate);
38873 if (PyErr_Occurred()) SWIG_fail;
38874 }
38875 resultobj = SWIG_Py_Void();
38876 return resultobj;
38877 fail:
38878 return NULL;
38879 }
38880
38881
38882 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38883 PyObject *resultobj = 0;
38884 wxWindow *arg1 = (wxWindow *) 0 ;
38885 bool result;
38886 void *argp1 = 0 ;
38887 int res1 = 0 ;
38888 PyObject *swig_obj[1] ;
38889
38890 if (!args) SWIG_fail;
38891 swig_obj[0] = args;
38892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38893 if (!SWIG_IsOK(res1)) {
38894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38895 }
38896 arg1 = reinterpret_cast< wxWindow * >(argp1);
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38913 PyObject *resultobj = 0;
38914 wxWindow *arg1 = (wxWindow *) 0 ;
38915 bool result;
38916 void *argp1 = 0 ;
38917 int res1 = 0 ;
38918 PyObject *swig_obj[1] ;
38919
38920 if (!args) SWIG_fail;
38921 swig_obj[0] = args;
38922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38923 if (!SWIG_IsOK(res1)) {
38924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38925 }
38926 arg1 = reinterpret_cast< wxWindow * >(argp1);
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (bool)(arg1)->CanSetTransparent();
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 {
38934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38935 }
38936 return resultobj;
38937 fail:
38938 return NULL;
38939 }
38940
38941
38942 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38943 PyObject *resultobj = 0;
38944 wxWindow *arg1 = (wxWindow *) 0 ;
38945 byte arg2 ;
38946 bool result;
38947 void *argp1 = 0 ;
38948 int res1 = 0 ;
38949 unsigned char val2 ;
38950 int ecode2 = 0 ;
38951 PyObject * obj0 = 0 ;
38952 PyObject * obj1 = 0 ;
38953 char * kwnames[] = {
38954 (char *) "self",(char *) "alpha", NULL
38955 };
38956
38957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38959 if (!SWIG_IsOK(res1)) {
38960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38961 }
38962 arg1 = reinterpret_cast< wxWindow * >(argp1);
38963 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38964 if (!SWIG_IsOK(ecode2)) {
38965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38966 }
38967 arg2 = static_cast< byte >(val2);
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (bool)(arg1)->SetTransparent(arg2);
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 {
38975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38976 }
38977 return resultobj;
38978 fail:
38979 return NULL;
38980 }
38981
38982
38983 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38984 PyObject *obj;
38985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38986 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38987 return SWIG_Py_Void();
38988 }
38989
38990 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38991 return SWIG_Python_InitShadowInstance(args);
38992 }
38993
38994 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38995 PyObject *resultobj = 0;
38996 long arg1 ;
38997 wxWindow *arg2 = (wxWindow *) NULL ;
38998 wxWindow *result = 0 ;
38999 long val1 ;
39000 int ecode1 = 0 ;
39001 void *argp2 = 0 ;
39002 int res2 = 0 ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "id",(char *) "parent", NULL
39007 };
39008
39009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
39010 ecode1 = SWIG_AsVal_long(obj0, &val1);
39011 if (!SWIG_IsOK(ecode1)) {
39012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
39013 }
39014 arg1 = static_cast< long >(val1);
39015 if (obj1) {
39016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39017 if (!SWIG_IsOK(res2)) {
39018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
39019 }
39020 arg2 = reinterpret_cast< wxWindow * >(argp2);
39021 }
39022 {
39023 if (!wxPyCheckForApp()) SWIG_fail;
39024 PyThreadState* __tstate = wxPyBeginAllowThreads();
39025 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39026 wxPyEndAllowThreads(__tstate);
39027 if (PyErr_Occurred()) SWIG_fail;
39028 }
39029 {
39030 resultobj = wxPyMake_wxObject(result, 0);
39031 }
39032 return resultobj;
39033 fail:
39034 return NULL;
39035 }
39036
39037
39038 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39039 PyObject *resultobj = 0;
39040 wxString *arg1 = 0 ;
39041 wxWindow *arg2 = (wxWindow *) NULL ;
39042 wxWindow *result = 0 ;
39043 bool temp1 = false ;
39044 void *argp2 = 0 ;
39045 int res2 = 0 ;
39046 PyObject * obj0 = 0 ;
39047 PyObject * obj1 = 0 ;
39048 char * kwnames[] = {
39049 (char *) "name",(char *) "parent", NULL
39050 };
39051
39052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39053 {
39054 arg1 = wxString_in_helper(obj0);
39055 if (arg1 == NULL) SWIG_fail;
39056 temp1 = true;
39057 }
39058 if (obj1) {
39059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39060 if (!SWIG_IsOK(res2)) {
39061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39062 }
39063 arg2 = reinterpret_cast< wxWindow * >(argp2);
39064 }
39065 {
39066 if (!wxPyCheckForApp()) SWIG_fail;
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39069 wxPyEndAllowThreads(__tstate);
39070 if (PyErr_Occurred()) SWIG_fail;
39071 }
39072 {
39073 resultobj = wxPyMake_wxObject(result, 0);
39074 }
39075 {
39076 if (temp1)
39077 delete arg1;
39078 }
39079 return resultobj;
39080 fail:
39081 {
39082 if (temp1)
39083 delete arg1;
39084 }
39085 return NULL;
39086 }
39087
39088
39089 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39090 PyObject *resultobj = 0;
39091 wxString *arg1 = 0 ;
39092 wxWindow *arg2 = (wxWindow *) NULL ;
39093 wxWindow *result = 0 ;
39094 bool temp1 = false ;
39095 void *argp2 = 0 ;
39096 int res2 = 0 ;
39097 PyObject * obj0 = 0 ;
39098 PyObject * obj1 = 0 ;
39099 char * kwnames[] = {
39100 (char *) "label",(char *) "parent", NULL
39101 };
39102
39103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39104 {
39105 arg1 = wxString_in_helper(obj0);
39106 if (arg1 == NULL) SWIG_fail;
39107 temp1 = true;
39108 }
39109 if (obj1) {
39110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39111 if (!SWIG_IsOK(res2)) {
39112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39113 }
39114 arg2 = reinterpret_cast< wxWindow * >(argp2);
39115 }
39116 {
39117 if (!wxPyCheckForApp()) SWIG_fail;
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = wxPyMake_wxObject(result, 0);
39125 }
39126 {
39127 if (temp1)
39128 delete arg1;
39129 }
39130 return resultobj;
39131 fail:
39132 {
39133 if (temp1)
39134 delete arg1;
39135 }
39136 return NULL;
39137 }
39138
39139
39140 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39141 PyObject *resultobj = 0;
39142 wxWindow *arg1 = (wxWindow *) 0 ;
39143 unsigned long arg2 ;
39144 wxWindow *result = 0 ;
39145 void *argp1 = 0 ;
39146 int res1 = 0 ;
39147 unsigned long val2 ;
39148 int ecode2 = 0 ;
39149 PyObject * obj0 = 0 ;
39150 PyObject * obj1 = 0 ;
39151 char * kwnames[] = {
39152 (char *) "parent",(char *) "_hWnd", NULL
39153 };
39154
39155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39157 if (!SWIG_IsOK(res1)) {
39158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39159 }
39160 arg1 = reinterpret_cast< wxWindow * >(argp1);
39161 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39162 if (!SWIG_IsOK(ecode2)) {
39163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39164 }
39165 arg2 = static_cast< unsigned long >(val2);
39166 {
39167 PyThreadState* __tstate = wxPyBeginAllowThreads();
39168 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = wxPyMake_wxObject(result, 0);
39174 }
39175 return resultobj;
39176 fail:
39177 return NULL;
39178 }
39179
39180
39181 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39182 PyObject *resultobj = 0;
39183 PyObject *result = 0 ;
39184
39185 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39186 {
39187 PyThreadState* __tstate = wxPyBeginAllowThreads();
39188 result = (PyObject *)GetTopLevelWindows();
39189 wxPyEndAllowThreads(__tstate);
39190 if (PyErr_Occurred()) SWIG_fail;
39191 }
39192 resultobj = result;
39193 return resultobj;
39194 fail:
39195 return NULL;
39196 }
39197
39198
39199 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39200 PyObject *resultobj = 0;
39201 wxValidator *result = 0 ;
39202
39203 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 result = (wxValidator *)new wxValidator();
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39218 PyObject *resultobj = 0;
39219 wxValidator *arg1 = (wxValidator *) 0 ;
39220 wxValidator *result = 0 ;
39221 void *argp1 = 0 ;
39222 int res1 = 0 ;
39223 PyObject *swig_obj[1] ;
39224
39225 if (!args) SWIG_fail;
39226 swig_obj[0] = args;
39227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39228 if (!SWIG_IsOK(res1)) {
39229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39230 }
39231 arg1 = reinterpret_cast< wxValidator * >(argp1);
39232 {
39233 PyThreadState* __tstate = wxPyBeginAllowThreads();
39234 result = (wxValidator *)(arg1)->Clone();
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, 0);
39240 }
39241 return resultobj;
39242 fail:
39243 return NULL;
39244 }
39245
39246
39247 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39248 PyObject *resultobj = 0;
39249 wxValidator *arg1 = (wxValidator *) 0 ;
39250 wxWindow *arg2 = (wxWindow *) 0 ;
39251 bool result;
39252 void *argp1 = 0 ;
39253 int res1 = 0 ;
39254 void *argp2 = 0 ;
39255 int res2 = 0 ;
39256 PyObject * obj0 = 0 ;
39257 PyObject * obj1 = 0 ;
39258 char * kwnames[] = {
39259 (char *) "self",(char *) "parent", NULL
39260 };
39261
39262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39264 if (!SWIG_IsOK(res1)) {
39265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39266 }
39267 arg1 = reinterpret_cast< wxValidator * >(argp1);
39268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39269 if (!SWIG_IsOK(res2)) {
39270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39271 }
39272 arg2 = reinterpret_cast< wxWindow * >(argp2);
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 result = (bool)(arg1)->Validate(arg2);
39276 wxPyEndAllowThreads(__tstate);
39277 if (PyErr_Occurred()) SWIG_fail;
39278 }
39279 {
39280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39281 }
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39289 PyObject *resultobj = 0;
39290 wxValidator *arg1 = (wxValidator *) 0 ;
39291 bool result;
39292 void *argp1 = 0 ;
39293 int res1 = 0 ;
39294 PyObject *swig_obj[1] ;
39295
39296 if (!args) SWIG_fail;
39297 swig_obj[0] = args;
39298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39299 if (!SWIG_IsOK(res1)) {
39300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39301 }
39302 arg1 = reinterpret_cast< wxValidator * >(argp1);
39303 {
39304 PyThreadState* __tstate = wxPyBeginAllowThreads();
39305 result = (bool)(arg1)->TransferToWindow();
39306 wxPyEndAllowThreads(__tstate);
39307 if (PyErr_Occurred()) SWIG_fail;
39308 }
39309 {
39310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39311 }
39312 return resultobj;
39313 fail:
39314 return NULL;
39315 }
39316
39317
39318 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39319 PyObject *resultobj = 0;
39320 wxValidator *arg1 = (wxValidator *) 0 ;
39321 bool result;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 PyObject *swig_obj[1] ;
39325
39326 if (!args) SWIG_fail;
39327 swig_obj[0] = args;
39328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39331 }
39332 arg1 = reinterpret_cast< wxValidator * >(argp1);
39333 {
39334 PyThreadState* __tstate = wxPyBeginAllowThreads();
39335 result = (bool)(arg1)->TransferFromWindow();
39336 wxPyEndAllowThreads(__tstate);
39337 if (PyErr_Occurred()) SWIG_fail;
39338 }
39339 {
39340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39341 }
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39349 PyObject *resultobj = 0;
39350 wxValidator *arg1 = (wxValidator *) 0 ;
39351 wxWindow *result = 0 ;
39352 void *argp1 = 0 ;
39353 int res1 = 0 ;
39354 PyObject *swig_obj[1] ;
39355
39356 if (!args) SWIG_fail;
39357 swig_obj[0] = args;
39358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39359 if (!SWIG_IsOK(res1)) {
39360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39361 }
39362 arg1 = reinterpret_cast< wxValidator * >(argp1);
39363 {
39364 PyThreadState* __tstate = wxPyBeginAllowThreads();
39365 result = (wxWindow *)(arg1)->GetWindow();
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 {
39370 resultobj = wxPyMake_wxObject(result, 0);
39371 }
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj = 0;
39380 wxValidator *arg1 = (wxValidator *) 0 ;
39381 wxWindow *arg2 = (wxWindow *) 0 ;
39382 void *argp1 = 0 ;
39383 int res1 = 0 ;
39384 void *argp2 = 0 ;
39385 int res2 = 0 ;
39386 PyObject * obj0 = 0 ;
39387 PyObject * obj1 = 0 ;
39388 char * kwnames[] = {
39389 (char *) "self",(char *) "window", NULL
39390 };
39391
39392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39394 if (!SWIG_IsOK(res1)) {
39395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39396 }
39397 arg1 = reinterpret_cast< wxValidator * >(argp1);
39398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39399 if (!SWIG_IsOK(res2)) {
39400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39401 }
39402 arg2 = reinterpret_cast< wxWindow * >(argp2);
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 (arg1)->SetWindow(arg2);
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 resultobj = SWIG_Py_Void();
39410 return resultobj;
39411 fail:
39412 return NULL;
39413 }
39414
39415
39416 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39417 PyObject *resultobj = 0;
39418 bool result;
39419
39420 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39421 {
39422 PyThreadState* __tstate = wxPyBeginAllowThreads();
39423 result = (bool)wxValidator::IsSilent();
39424 wxPyEndAllowThreads(__tstate);
39425 if (PyErr_Occurred()) SWIG_fail;
39426 }
39427 {
39428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39429 }
39430 return resultobj;
39431 fail:
39432 return NULL;
39433 }
39434
39435
39436 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39437 PyObject *resultobj = 0;
39438 int arg1 = (int) true ;
39439 int val1 ;
39440 int ecode1 = 0 ;
39441 PyObject * obj0 = 0 ;
39442 char * kwnames[] = {
39443 (char *) "doIt", NULL
39444 };
39445
39446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39447 if (obj0) {
39448 ecode1 = SWIG_AsVal_int(obj0, &val1);
39449 if (!SWIG_IsOK(ecode1)) {
39450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39451 }
39452 arg1 = static_cast< int >(val1);
39453 }
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 wxValidator::SetBellOnError(arg1);
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 resultobj = SWIG_Py_Void();
39461 return resultobj;
39462 fail:
39463 return NULL;
39464 }
39465
39466
39467 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39468 PyObject *obj;
39469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39470 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39471 return SWIG_Py_Void();
39472 }
39473
39474 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39475 return SWIG_Python_InitShadowInstance(args);
39476 }
39477
39478 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39479 PyObject *resultobj = 0;
39480 wxPyValidator *result = 0 ;
39481
39482 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (wxPyValidator *)new wxPyValidator();
39486 wxPyEndAllowThreads(__tstate);
39487 if (PyErr_Occurred()) SWIG_fail;
39488 }
39489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39490 return resultobj;
39491 fail:
39492 return NULL;
39493 }
39494
39495
39496 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39497 PyObject *resultobj = 0;
39498 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39499 PyObject *arg2 = (PyObject *) 0 ;
39500 PyObject *arg3 = (PyObject *) 0 ;
39501 int arg4 = (int) true ;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 int val4 ;
39505 int ecode4 = 0 ;
39506 PyObject * obj0 = 0 ;
39507 PyObject * obj1 = 0 ;
39508 PyObject * obj2 = 0 ;
39509 PyObject * obj3 = 0 ;
39510 char * kwnames[] = {
39511 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39512 };
39513
39514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39516 if (!SWIG_IsOK(res1)) {
39517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39518 }
39519 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39520 arg2 = obj1;
39521 arg3 = obj2;
39522 if (obj3) {
39523 ecode4 = SWIG_AsVal_int(obj3, &val4);
39524 if (!SWIG_IsOK(ecode4)) {
39525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39526 }
39527 arg4 = static_cast< int >(val4);
39528 }
39529 {
39530 PyThreadState* __tstate = wxPyBeginAllowThreads();
39531 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39532 wxPyEndAllowThreads(__tstate);
39533 if (PyErr_Occurred()) SWIG_fail;
39534 }
39535 resultobj = SWIG_Py_Void();
39536 return resultobj;
39537 fail:
39538 return NULL;
39539 }
39540
39541
39542 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39543 PyObject *obj;
39544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39546 return SWIG_Py_Void();
39547 }
39548
39549 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39550 return SWIG_Python_InitShadowInstance(args);
39551 }
39552
39553 SWIGINTERN int DefaultValidator_set(PyObject *) {
39554 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39555 return 1;
39556 }
39557
39558
39559 SWIGINTERN PyObject *DefaultValidator_get(void) {
39560 PyObject *pyobj = 0;
39561
39562 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39563 return pyobj;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj = 0;
39569 wxString const &arg1_defvalue = wxPyEmptyString ;
39570 wxString *arg1 = (wxString *) &arg1_defvalue ;
39571 long arg2 = (long) 0 ;
39572 wxMenu *result = 0 ;
39573 bool temp1 = false ;
39574 long val2 ;
39575 int ecode2 = 0 ;
39576 PyObject * obj0 = 0 ;
39577 PyObject * obj1 = 0 ;
39578 char * kwnames[] = {
39579 (char *) "title",(char *) "style", NULL
39580 };
39581
39582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39583 if (obj0) {
39584 {
39585 arg1 = wxString_in_helper(obj0);
39586 if (arg1 == NULL) SWIG_fail;
39587 temp1 = true;
39588 }
39589 }
39590 if (obj1) {
39591 ecode2 = SWIG_AsVal_long(obj1, &val2);
39592 if (!SWIG_IsOK(ecode2)) {
39593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39594 }
39595 arg2 = static_cast< long >(val2);
39596 }
39597 {
39598 if (!wxPyCheckForApp()) SWIG_fail;
39599 PyThreadState* __tstate = wxPyBeginAllowThreads();
39600 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39601 wxPyEndAllowThreads(__tstate);
39602 if (PyErr_Occurred()) SWIG_fail;
39603 }
39604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39605 {
39606 if (temp1)
39607 delete arg1;
39608 }
39609 return resultobj;
39610 fail:
39611 {
39612 if (temp1)
39613 delete arg1;
39614 }
39615 return NULL;
39616 }
39617
39618
39619 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39620 PyObject *resultobj = 0;
39621 wxMenu *arg1 = (wxMenu *) 0 ;
39622 int arg2 ;
39623 wxString const &arg3_defvalue = wxPyEmptyString ;
39624 wxString *arg3 = (wxString *) &arg3_defvalue ;
39625 wxString const &arg4_defvalue = wxPyEmptyString ;
39626 wxString *arg4 = (wxString *) &arg4_defvalue ;
39627 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39628 wxMenuItem *result = 0 ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 int val2 ;
39632 int ecode2 = 0 ;
39633 bool temp3 = false ;
39634 bool temp4 = false ;
39635 int val5 ;
39636 int ecode5 = 0 ;
39637 PyObject * obj0 = 0 ;
39638 PyObject * obj1 = 0 ;
39639 PyObject * obj2 = 0 ;
39640 PyObject * obj3 = 0 ;
39641 PyObject * obj4 = 0 ;
39642 char * kwnames[] = {
39643 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39644 };
39645
39646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39648 if (!SWIG_IsOK(res1)) {
39649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39650 }
39651 arg1 = reinterpret_cast< wxMenu * >(argp1);
39652 ecode2 = SWIG_AsVal_int(obj1, &val2);
39653 if (!SWIG_IsOK(ecode2)) {
39654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39655 }
39656 arg2 = static_cast< int >(val2);
39657 if (obj2) {
39658 {
39659 arg3 = wxString_in_helper(obj2);
39660 if (arg3 == NULL) SWIG_fail;
39661 temp3 = true;
39662 }
39663 }
39664 if (obj3) {
39665 {
39666 arg4 = wxString_in_helper(obj3);
39667 if (arg4 == NULL) SWIG_fail;
39668 temp4 = true;
39669 }
39670 }
39671 if (obj4) {
39672 ecode5 = SWIG_AsVal_int(obj4, &val5);
39673 if (!SWIG_IsOK(ecode5)) {
39674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39675 }
39676 arg5 = static_cast< wxItemKind >(val5);
39677 }
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 {
39685 resultobj = wxPyMake_wxObject(result, (bool)0);
39686 }
39687 {
39688 if (temp3)
39689 delete arg3;
39690 }
39691 {
39692 if (temp4)
39693 delete arg4;
39694 }
39695 return resultobj;
39696 fail:
39697 {
39698 if (temp3)
39699 delete arg3;
39700 }
39701 {
39702 if (temp4)
39703 delete arg4;
39704 }
39705 return NULL;
39706 }
39707
39708
39709 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39710 PyObject *resultobj = 0;
39711 wxMenu *arg1 = (wxMenu *) 0 ;
39712 wxMenuItem *result = 0 ;
39713 void *argp1 = 0 ;
39714 int res1 = 0 ;
39715 PyObject *swig_obj[1] ;
39716
39717 if (!args) SWIG_fail;
39718 swig_obj[0] = args;
39719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39720 if (!SWIG_IsOK(res1)) {
39721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39722 }
39723 arg1 = reinterpret_cast< wxMenu * >(argp1);
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 result = (wxMenuItem *)(arg1)->AppendSeparator();
39727 wxPyEndAllowThreads(__tstate);
39728 if (PyErr_Occurred()) SWIG_fail;
39729 }
39730 {
39731 resultobj = wxPyMake_wxObject(result, (bool)0);
39732 }
39733 return resultobj;
39734 fail:
39735 return NULL;
39736 }
39737
39738
39739 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39740 PyObject *resultobj = 0;
39741 wxMenu *arg1 = (wxMenu *) 0 ;
39742 int arg2 ;
39743 wxString *arg3 = 0 ;
39744 wxString const &arg4_defvalue = wxPyEmptyString ;
39745 wxString *arg4 = (wxString *) &arg4_defvalue ;
39746 wxMenuItem *result = 0 ;
39747 void *argp1 = 0 ;
39748 int res1 = 0 ;
39749 int val2 ;
39750 int ecode2 = 0 ;
39751 bool temp3 = false ;
39752 bool temp4 = false ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 PyObject * obj2 = 0 ;
39756 PyObject * obj3 = 0 ;
39757 char * kwnames[] = {
39758 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39759 };
39760
39761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39763 if (!SWIG_IsOK(res1)) {
39764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39765 }
39766 arg1 = reinterpret_cast< wxMenu * >(argp1);
39767 ecode2 = SWIG_AsVal_int(obj1, &val2);
39768 if (!SWIG_IsOK(ecode2)) {
39769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39770 }
39771 arg2 = static_cast< int >(val2);
39772 {
39773 arg3 = wxString_in_helper(obj2);
39774 if (arg3 == NULL) SWIG_fail;
39775 temp3 = true;
39776 }
39777 if (obj3) {
39778 {
39779 arg4 = wxString_in_helper(obj3);
39780 if (arg4 == NULL) SWIG_fail;
39781 temp4 = true;
39782 }
39783 }
39784 {
39785 PyThreadState* __tstate = wxPyBeginAllowThreads();
39786 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39787 wxPyEndAllowThreads(__tstate);
39788 if (PyErr_Occurred()) SWIG_fail;
39789 }
39790 {
39791 resultobj = wxPyMake_wxObject(result, (bool)0);
39792 }
39793 {
39794 if (temp3)
39795 delete arg3;
39796 }
39797 {
39798 if (temp4)
39799 delete arg4;
39800 }
39801 return resultobj;
39802 fail:
39803 {
39804 if (temp3)
39805 delete arg3;
39806 }
39807 {
39808 if (temp4)
39809 delete arg4;
39810 }
39811 return NULL;
39812 }
39813
39814
39815 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj = 0;
39817 wxMenu *arg1 = (wxMenu *) 0 ;
39818 int arg2 ;
39819 wxString *arg3 = 0 ;
39820 wxString const &arg4_defvalue = wxPyEmptyString ;
39821 wxString *arg4 = (wxString *) &arg4_defvalue ;
39822 wxMenuItem *result = 0 ;
39823 void *argp1 = 0 ;
39824 int res1 = 0 ;
39825 int val2 ;
39826 int ecode2 = 0 ;
39827 bool temp3 = false ;
39828 bool temp4 = false ;
39829 PyObject * obj0 = 0 ;
39830 PyObject * obj1 = 0 ;
39831 PyObject * obj2 = 0 ;
39832 PyObject * obj3 = 0 ;
39833 char * kwnames[] = {
39834 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39835 };
39836
39837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res1)) {
39840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39841 }
39842 arg1 = reinterpret_cast< wxMenu * >(argp1);
39843 ecode2 = SWIG_AsVal_int(obj1, &val2);
39844 if (!SWIG_IsOK(ecode2)) {
39845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39846 }
39847 arg2 = static_cast< int >(val2);
39848 {
39849 arg3 = wxString_in_helper(obj2);
39850 if (arg3 == NULL) SWIG_fail;
39851 temp3 = true;
39852 }
39853 if (obj3) {
39854 {
39855 arg4 = wxString_in_helper(obj3);
39856 if (arg4 == NULL) SWIG_fail;
39857 temp4 = true;
39858 }
39859 }
39860 {
39861 PyThreadState* __tstate = wxPyBeginAllowThreads();
39862 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 {
39867 resultobj = wxPyMake_wxObject(result, (bool)0);
39868 }
39869 {
39870 if (temp3)
39871 delete arg3;
39872 }
39873 {
39874 if (temp4)
39875 delete arg4;
39876 }
39877 return resultobj;
39878 fail:
39879 {
39880 if (temp3)
39881 delete arg3;
39882 }
39883 {
39884 if (temp4)
39885 delete arg4;
39886 }
39887 return NULL;
39888 }
39889
39890
39891 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj = 0;
39893 wxMenu *arg1 = (wxMenu *) 0 ;
39894 int arg2 ;
39895 wxString *arg3 = 0 ;
39896 wxMenu *arg4 = (wxMenu *) 0 ;
39897 wxString const &arg5_defvalue = wxPyEmptyString ;
39898 wxString *arg5 = (wxString *) &arg5_defvalue ;
39899 wxMenuItem *result = 0 ;
39900 void *argp1 = 0 ;
39901 int res1 = 0 ;
39902 int val2 ;
39903 int ecode2 = 0 ;
39904 bool temp3 = false ;
39905 void *argp4 = 0 ;
39906 int res4 = 0 ;
39907 bool temp5 = false ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 PyObject * obj2 = 0 ;
39911 PyObject * obj3 = 0 ;
39912 PyObject * obj4 = 0 ;
39913 char * kwnames[] = {
39914 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39915 };
39916
39917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39919 if (!SWIG_IsOK(res1)) {
39920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39921 }
39922 arg1 = reinterpret_cast< wxMenu * >(argp1);
39923 ecode2 = SWIG_AsVal_int(obj1, &val2);
39924 if (!SWIG_IsOK(ecode2)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39926 }
39927 arg2 = static_cast< int >(val2);
39928 {
39929 arg3 = wxString_in_helper(obj2);
39930 if (arg3 == NULL) SWIG_fail;
39931 temp3 = true;
39932 }
39933 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res4)) {
39935 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39936 }
39937 arg4 = reinterpret_cast< wxMenu * >(argp4);
39938 if (obj4) {
39939 {
39940 arg5 = wxString_in_helper(obj4);
39941 if (arg5 == NULL) SWIG_fail;
39942 temp5 = true;
39943 }
39944 }
39945 {
39946 PyThreadState* __tstate = wxPyBeginAllowThreads();
39947 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 {
39952 resultobj = wxPyMake_wxObject(result, (bool)0);
39953 }
39954 {
39955 if (temp3)
39956 delete arg3;
39957 }
39958 {
39959 if (temp5)
39960 delete arg5;
39961 }
39962 return resultobj;
39963 fail:
39964 {
39965 if (temp3)
39966 delete arg3;
39967 }
39968 {
39969 if (temp5)
39970 delete arg5;
39971 }
39972 return NULL;
39973 }
39974
39975
39976 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39977 PyObject *resultobj = 0;
39978 wxMenu *arg1 = (wxMenu *) 0 ;
39979 wxMenu *arg2 = (wxMenu *) 0 ;
39980 wxString *arg3 = 0 ;
39981 wxString const &arg4_defvalue = wxPyEmptyString ;
39982 wxString *arg4 = (wxString *) &arg4_defvalue ;
39983 wxMenuItem *result = 0 ;
39984 void *argp1 = 0 ;
39985 int res1 = 0 ;
39986 void *argp2 = 0 ;
39987 int res2 = 0 ;
39988 bool temp3 = false ;
39989 bool temp4 = false ;
39990 PyObject * obj0 = 0 ;
39991 PyObject * obj1 = 0 ;
39992 PyObject * obj2 = 0 ;
39993 PyObject * obj3 = 0 ;
39994 char * kwnames[] = {
39995 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39996 };
39997
39998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40000 if (!SWIG_IsOK(res1)) {
40001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40002 }
40003 arg1 = reinterpret_cast< wxMenu * >(argp1);
40004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40005 if (!SWIG_IsOK(res2)) {
40006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40007 }
40008 arg2 = reinterpret_cast< wxMenu * >(argp2);
40009 {
40010 arg3 = wxString_in_helper(obj2);
40011 if (arg3 == NULL) SWIG_fail;
40012 temp3 = true;
40013 }
40014 if (obj3) {
40015 {
40016 arg4 = wxString_in_helper(obj3);
40017 if (arg4 == NULL) SWIG_fail;
40018 temp4 = true;
40019 }
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 {
40028 resultobj = wxPyMake_wxObject(result, (bool)0);
40029 }
40030 {
40031 if (temp3)
40032 delete arg3;
40033 }
40034 {
40035 if (temp4)
40036 delete arg4;
40037 }
40038 return resultobj;
40039 fail:
40040 {
40041 if (temp3)
40042 delete arg3;
40043 }
40044 {
40045 if (temp4)
40046 delete arg4;
40047 }
40048 return NULL;
40049 }
40050
40051
40052 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40053 PyObject *resultobj = 0;
40054 wxMenu *arg1 = (wxMenu *) 0 ;
40055 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40056 wxMenuItem *result = 0 ;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 int res2 = 0 ;
40060 PyObject * obj0 = 0 ;
40061 PyObject * obj1 = 0 ;
40062 char * kwnames[] = {
40063 (char *) "self",(char *) "item", NULL
40064 };
40065
40066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40068 if (!SWIG_IsOK(res1)) {
40069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40070 }
40071 arg1 = reinterpret_cast< wxMenu * >(argp1);
40072 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40073 if (!SWIG_IsOK(res2)) {
40074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40075 }
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 result = (wxMenuItem *)(arg1)->Append(arg2);
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 {
40083 resultobj = wxPyMake_wxObject(result, (bool)0);
40084 }
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40092 PyObject *resultobj = 0;
40093 wxMenu *arg1 = (wxMenu *) 0 ;
40094 size_t arg2 ;
40095 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40096 wxMenuItem *result = 0 ;
40097 void *argp1 = 0 ;
40098 int res1 = 0 ;
40099 size_t val2 ;
40100 int ecode2 = 0 ;
40101 int res3 = 0 ;
40102 PyObject * obj0 = 0 ;
40103 PyObject * obj1 = 0 ;
40104 PyObject * obj2 = 0 ;
40105 char * kwnames[] = {
40106 (char *) "self",(char *) "pos",(char *) "item", NULL
40107 };
40108
40109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40111 if (!SWIG_IsOK(res1)) {
40112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40113 }
40114 arg1 = reinterpret_cast< wxMenu * >(argp1);
40115 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40116 if (!SWIG_IsOK(ecode2)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40118 }
40119 arg2 = static_cast< size_t >(val2);
40120 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40121 if (!SWIG_IsOK(res3)) {
40122 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40123 }
40124 {
40125 PyThreadState* __tstate = wxPyBeginAllowThreads();
40126 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40127 wxPyEndAllowThreads(__tstate);
40128 if (PyErr_Occurred()) SWIG_fail;
40129 }
40130 {
40131 resultobj = wxPyMake_wxObject(result, (bool)0);
40132 }
40133 return resultobj;
40134 fail:
40135 return NULL;
40136 }
40137
40138
40139 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40140 PyObject *resultobj = 0;
40141 wxMenu *arg1 = (wxMenu *) 0 ;
40142 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40143 wxMenuItem *result = 0 ;
40144 void *argp1 = 0 ;
40145 int res1 = 0 ;
40146 int res2 = 0 ;
40147 PyObject * obj0 = 0 ;
40148 PyObject * obj1 = 0 ;
40149 char * kwnames[] = {
40150 (char *) "self",(char *) "item", NULL
40151 };
40152
40153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40155 if (!SWIG_IsOK(res1)) {
40156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40157 }
40158 arg1 = reinterpret_cast< wxMenu * >(argp1);
40159 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40160 if (!SWIG_IsOK(res2)) {
40161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40162 }
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40166 wxPyEndAllowThreads(__tstate);
40167 if (PyErr_Occurred()) SWIG_fail;
40168 }
40169 {
40170 resultobj = wxPyMake_wxObject(result, (bool)0);
40171 }
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40179 PyObject *resultobj = 0;
40180 wxMenu *arg1 = (wxMenu *) 0 ;
40181 void *argp1 = 0 ;
40182 int res1 = 0 ;
40183 PyObject *swig_obj[1] ;
40184
40185 if (!args) SWIG_fail;
40186 swig_obj[0] = args;
40187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 (arg1)->Break();
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 resultobj = SWIG_Py_Void();
40199 return resultobj;
40200 fail:
40201 return NULL;
40202 }
40203
40204
40205 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40206 PyObject *resultobj = 0;
40207 wxMenu *arg1 = (wxMenu *) 0 ;
40208 size_t arg2 ;
40209 int arg3 ;
40210 wxString const &arg4_defvalue = wxPyEmptyString ;
40211 wxString *arg4 = (wxString *) &arg4_defvalue ;
40212 wxString const &arg5_defvalue = wxPyEmptyString ;
40213 wxString *arg5 = (wxString *) &arg5_defvalue ;
40214 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40215 wxMenuItem *result = 0 ;
40216 void *argp1 = 0 ;
40217 int res1 = 0 ;
40218 size_t val2 ;
40219 int ecode2 = 0 ;
40220 int val3 ;
40221 int ecode3 = 0 ;
40222 bool temp4 = false ;
40223 bool temp5 = false ;
40224 int val6 ;
40225 int ecode6 = 0 ;
40226 PyObject * obj0 = 0 ;
40227 PyObject * obj1 = 0 ;
40228 PyObject * obj2 = 0 ;
40229 PyObject * obj3 = 0 ;
40230 PyObject * obj4 = 0 ;
40231 PyObject * obj5 = 0 ;
40232 char * kwnames[] = {
40233 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40234 };
40235
40236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40238 if (!SWIG_IsOK(res1)) {
40239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40240 }
40241 arg1 = reinterpret_cast< wxMenu * >(argp1);
40242 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40243 if (!SWIG_IsOK(ecode2)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40245 }
40246 arg2 = static_cast< size_t >(val2);
40247 ecode3 = SWIG_AsVal_int(obj2, &val3);
40248 if (!SWIG_IsOK(ecode3)) {
40249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40250 }
40251 arg3 = static_cast< int >(val3);
40252 if (obj3) {
40253 {
40254 arg4 = wxString_in_helper(obj3);
40255 if (arg4 == NULL) SWIG_fail;
40256 temp4 = true;
40257 }
40258 }
40259 if (obj4) {
40260 {
40261 arg5 = wxString_in_helper(obj4);
40262 if (arg5 == NULL) SWIG_fail;
40263 temp5 = true;
40264 }
40265 }
40266 if (obj5) {
40267 ecode6 = SWIG_AsVal_int(obj5, &val6);
40268 if (!SWIG_IsOK(ecode6)) {
40269 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40270 }
40271 arg6 = static_cast< wxItemKind >(val6);
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 {
40280 resultobj = wxPyMake_wxObject(result, (bool)0);
40281 }
40282 {
40283 if (temp4)
40284 delete arg4;
40285 }
40286 {
40287 if (temp5)
40288 delete arg5;
40289 }
40290 return resultobj;
40291 fail:
40292 {
40293 if (temp4)
40294 delete arg4;
40295 }
40296 {
40297 if (temp5)
40298 delete arg5;
40299 }
40300 return NULL;
40301 }
40302
40303
40304 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40305 PyObject *resultobj = 0;
40306 wxMenu *arg1 = (wxMenu *) 0 ;
40307 size_t arg2 ;
40308 wxMenuItem *result = 0 ;
40309 void *argp1 = 0 ;
40310 int res1 = 0 ;
40311 size_t val2 ;
40312 int ecode2 = 0 ;
40313 PyObject * obj0 = 0 ;
40314 PyObject * obj1 = 0 ;
40315 char * kwnames[] = {
40316 (char *) "self",(char *) "pos", NULL
40317 };
40318
40319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40321 if (!SWIG_IsOK(res1)) {
40322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40323 }
40324 arg1 = reinterpret_cast< wxMenu * >(argp1);
40325 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40326 if (!SWIG_IsOK(ecode2)) {
40327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40328 }
40329 arg2 = static_cast< size_t >(val2);
40330 {
40331 PyThreadState* __tstate = wxPyBeginAllowThreads();
40332 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40333 wxPyEndAllowThreads(__tstate);
40334 if (PyErr_Occurred()) SWIG_fail;
40335 }
40336 {
40337 resultobj = wxPyMake_wxObject(result, (bool)0);
40338 }
40339 return resultobj;
40340 fail:
40341 return NULL;
40342 }
40343
40344
40345 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40346 PyObject *resultobj = 0;
40347 wxMenu *arg1 = (wxMenu *) 0 ;
40348 size_t arg2 ;
40349 int arg3 ;
40350 wxString *arg4 = 0 ;
40351 wxString const &arg5_defvalue = wxPyEmptyString ;
40352 wxString *arg5 = (wxString *) &arg5_defvalue ;
40353 wxMenuItem *result = 0 ;
40354 void *argp1 = 0 ;
40355 int res1 = 0 ;
40356 size_t val2 ;
40357 int ecode2 = 0 ;
40358 int val3 ;
40359 int ecode3 = 0 ;
40360 bool temp4 = false ;
40361 bool temp5 = false ;
40362 PyObject * obj0 = 0 ;
40363 PyObject * obj1 = 0 ;
40364 PyObject * obj2 = 0 ;
40365 PyObject * obj3 = 0 ;
40366 PyObject * obj4 = 0 ;
40367 char * kwnames[] = {
40368 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40369 };
40370
40371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40373 if (!SWIG_IsOK(res1)) {
40374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40375 }
40376 arg1 = reinterpret_cast< wxMenu * >(argp1);
40377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40378 if (!SWIG_IsOK(ecode2)) {
40379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40380 }
40381 arg2 = static_cast< size_t >(val2);
40382 ecode3 = SWIG_AsVal_int(obj2, &val3);
40383 if (!SWIG_IsOK(ecode3)) {
40384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40385 }
40386 arg3 = static_cast< int >(val3);
40387 {
40388 arg4 = wxString_in_helper(obj3);
40389 if (arg4 == NULL) SWIG_fail;
40390 temp4 = true;
40391 }
40392 if (obj4) {
40393 {
40394 arg5 = wxString_in_helper(obj4);
40395 if (arg5 == NULL) SWIG_fail;
40396 temp5 = true;
40397 }
40398 }
40399 {
40400 PyThreadState* __tstate = wxPyBeginAllowThreads();
40401 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 {
40406 resultobj = wxPyMake_wxObject(result, (bool)0);
40407 }
40408 {
40409 if (temp4)
40410 delete arg4;
40411 }
40412 {
40413 if (temp5)
40414 delete arg5;
40415 }
40416 return resultobj;
40417 fail:
40418 {
40419 if (temp4)
40420 delete arg4;
40421 }
40422 {
40423 if (temp5)
40424 delete arg5;
40425 }
40426 return NULL;
40427 }
40428
40429
40430 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40431 PyObject *resultobj = 0;
40432 wxMenu *arg1 = (wxMenu *) 0 ;
40433 size_t arg2 ;
40434 int arg3 ;
40435 wxString *arg4 = 0 ;
40436 wxString const &arg5_defvalue = wxPyEmptyString ;
40437 wxString *arg5 = (wxString *) &arg5_defvalue ;
40438 wxMenuItem *result = 0 ;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 size_t val2 ;
40442 int ecode2 = 0 ;
40443 int val3 ;
40444 int ecode3 = 0 ;
40445 bool temp4 = false ;
40446 bool temp5 = false ;
40447 PyObject * obj0 = 0 ;
40448 PyObject * obj1 = 0 ;
40449 PyObject * obj2 = 0 ;
40450 PyObject * obj3 = 0 ;
40451 PyObject * obj4 = 0 ;
40452 char * kwnames[] = {
40453 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40454 };
40455
40456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40458 if (!SWIG_IsOK(res1)) {
40459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40460 }
40461 arg1 = reinterpret_cast< wxMenu * >(argp1);
40462 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40463 if (!SWIG_IsOK(ecode2)) {
40464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40465 }
40466 arg2 = static_cast< size_t >(val2);
40467 ecode3 = SWIG_AsVal_int(obj2, &val3);
40468 if (!SWIG_IsOK(ecode3)) {
40469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40470 }
40471 arg3 = static_cast< int >(val3);
40472 {
40473 arg4 = wxString_in_helper(obj3);
40474 if (arg4 == NULL) SWIG_fail;
40475 temp4 = true;
40476 }
40477 if (obj4) {
40478 {
40479 arg5 = wxString_in_helper(obj4);
40480 if (arg5 == NULL) SWIG_fail;
40481 temp5 = true;
40482 }
40483 }
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 {
40491 resultobj = wxPyMake_wxObject(result, (bool)0);
40492 }
40493 {
40494 if (temp4)
40495 delete arg4;
40496 }
40497 {
40498 if (temp5)
40499 delete arg5;
40500 }
40501 return resultobj;
40502 fail:
40503 {
40504 if (temp4)
40505 delete arg4;
40506 }
40507 {
40508 if (temp5)
40509 delete arg5;
40510 }
40511 return NULL;
40512 }
40513
40514
40515 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj = 0;
40517 wxMenu *arg1 = (wxMenu *) 0 ;
40518 size_t arg2 ;
40519 int arg3 ;
40520 wxString *arg4 = 0 ;
40521 wxMenu *arg5 = (wxMenu *) 0 ;
40522 wxString const &arg6_defvalue = wxPyEmptyString ;
40523 wxString *arg6 = (wxString *) &arg6_defvalue ;
40524 wxMenuItem *result = 0 ;
40525 void *argp1 = 0 ;
40526 int res1 = 0 ;
40527 size_t val2 ;
40528 int ecode2 = 0 ;
40529 int val3 ;
40530 int ecode3 = 0 ;
40531 bool temp4 = false ;
40532 void *argp5 = 0 ;
40533 int res5 = 0 ;
40534 bool temp6 = false ;
40535 PyObject * obj0 = 0 ;
40536 PyObject * obj1 = 0 ;
40537 PyObject * obj2 = 0 ;
40538 PyObject * obj3 = 0 ;
40539 PyObject * obj4 = 0 ;
40540 PyObject * obj5 = 0 ;
40541 char * kwnames[] = {
40542 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40543 };
40544
40545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40547 if (!SWIG_IsOK(res1)) {
40548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40549 }
40550 arg1 = reinterpret_cast< wxMenu * >(argp1);
40551 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40552 if (!SWIG_IsOK(ecode2)) {
40553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40554 }
40555 arg2 = static_cast< size_t >(val2);
40556 ecode3 = SWIG_AsVal_int(obj2, &val3);
40557 if (!SWIG_IsOK(ecode3)) {
40558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40559 }
40560 arg3 = static_cast< int >(val3);
40561 {
40562 arg4 = wxString_in_helper(obj3);
40563 if (arg4 == NULL) SWIG_fail;
40564 temp4 = true;
40565 }
40566 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40567 if (!SWIG_IsOK(res5)) {
40568 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40569 }
40570 arg5 = reinterpret_cast< wxMenu * >(argp5);
40571 if (obj5) {
40572 {
40573 arg6 = wxString_in_helper(obj5);
40574 if (arg6 == NULL) SWIG_fail;
40575 temp6 = true;
40576 }
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 {
40585 resultobj = wxPyMake_wxObject(result, (bool)0);
40586 }
40587 {
40588 if (temp4)
40589 delete arg4;
40590 }
40591 {
40592 if (temp6)
40593 delete arg6;
40594 }
40595 return resultobj;
40596 fail:
40597 {
40598 if (temp4)
40599 delete arg4;
40600 }
40601 {
40602 if (temp6)
40603 delete arg6;
40604 }
40605 return NULL;
40606 }
40607
40608
40609 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj = 0;
40611 wxMenu *arg1 = (wxMenu *) 0 ;
40612 int arg2 ;
40613 wxString const &arg3_defvalue = wxPyEmptyString ;
40614 wxString *arg3 = (wxString *) &arg3_defvalue ;
40615 wxString const &arg4_defvalue = wxPyEmptyString ;
40616 wxString *arg4 = (wxString *) &arg4_defvalue ;
40617 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40618 wxMenuItem *result = 0 ;
40619 void *argp1 = 0 ;
40620 int res1 = 0 ;
40621 int val2 ;
40622 int ecode2 = 0 ;
40623 bool temp3 = false ;
40624 bool temp4 = false ;
40625 int val5 ;
40626 int ecode5 = 0 ;
40627 PyObject * obj0 = 0 ;
40628 PyObject * obj1 = 0 ;
40629 PyObject * obj2 = 0 ;
40630 PyObject * obj3 = 0 ;
40631 PyObject * obj4 = 0 ;
40632 char * kwnames[] = {
40633 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40634 };
40635
40636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40638 if (!SWIG_IsOK(res1)) {
40639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40640 }
40641 arg1 = reinterpret_cast< wxMenu * >(argp1);
40642 ecode2 = SWIG_AsVal_int(obj1, &val2);
40643 if (!SWIG_IsOK(ecode2)) {
40644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40645 }
40646 arg2 = static_cast< int >(val2);
40647 if (obj2) {
40648 {
40649 arg3 = wxString_in_helper(obj2);
40650 if (arg3 == NULL) SWIG_fail;
40651 temp3 = true;
40652 }
40653 }
40654 if (obj3) {
40655 {
40656 arg4 = wxString_in_helper(obj3);
40657 if (arg4 == NULL) SWIG_fail;
40658 temp4 = true;
40659 }
40660 }
40661 if (obj4) {
40662 ecode5 = SWIG_AsVal_int(obj4, &val5);
40663 if (!SWIG_IsOK(ecode5)) {
40664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40665 }
40666 arg5 = static_cast< wxItemKind >(val5);
40667 }
40668 {
40669 PyThreadState* __tstate = wxPyBeginAllowThreads();
40670 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40671 wxPyEndAllowThreads(__tstate);
40672 if (PyErr_Occurred()) SWIG_fail;
40673 }
40674 {
40675 resultobj = wxPyMake_wxObject(result, (bool)0);
40676 }
40677 {
40678 if (temp3)
40679 delete arg3;
40680 }
40681 {
40682 if (temp4)
40683 delete arg4;
40684 }
40685 return resultobj;
40686 fail:
40687 {
40688 if (temp3)
40689 delete arg3;
40690 }
40691 {
40692 if (temp4)
40693 delete arg4;
40694 }
40695 return NULL;
40696 }
40697
40698
40699 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40700 PyObject *resultobj = 0;
40701 wxMenu *arg1 = (wxMenu *) 0 ;
40702 wxMenuItem *result = 0 ;
40703 void *argp1 = 0 ;
40704 int res1 = 0 ;
40705 PyObject *swig_obj[1] ;
40706
40707 if (!args) SWIG_fail;
40708 swig_obj[0] = args;
40709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40710 if (!SWIG_IsOK(res1)) {
40711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40712 }
40713 arg1 = reinterpret_cast< wxMenu * >(argp1);
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (wxMenuItem *)(arg1)->PrependSeparator();
40717 wxPyEndAllowThreads(__tstate);
40718 if (PyErr_Occurred()) SWIG_fail;
40719 }
40720 {
40721 resultobj = wxPyMake_wxObject(result, (bool)0);
40722 }
40723 return resultobj;
40724 fail:
40725 return NULL;
40726 }
40727
40728
40729 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40730 PyObject *resultobj = 0;
40731 wxMenu *arg1 = (wxMenu *) 0 ;
40732 int arg2 ;
40733 wxString *arg3 = 0 ;
40734 wxString const &arg4_defvalue = wxPyEmptyString ;
40735 wxString *arg4 = (wxString *) &arg4_defvalue ;
40736 wxMenuItem *result = 0 ;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 int val2 ;
40740 int ecode2 = 0 ;
40741 bool temp3 = false ;
40742 bool temp4 = false ;
40743 PyObject * obj0 = 0 ;
40744 PyObject * obj1 = 0 ;
40745 PyObject * obj2 = 0 ;
40746 PyObject * obj3 = 0 ;
40747 char * kwnames[] = {
40748 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40749 };
40750
40751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40753 if (!SWIG_IsOK(res1)) {
40754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40755 }
40756 arg1 = reinterpret_cast< wxMenu * >(argp1);
40757 ecode2 = SWIG_AsVal_int(obj1, &val2);
40758 if (!SWIG_IsOK(ecode2)) {
40759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40760 }
40761 arg2 = static_cast< int >(val2);
40762 {
40763 arg3 = wxString_in_helper(obj2);
40764 if (arg3 == NULL) SWIG_fail;
40765 temp3 = true;
40766 }
40767 if (obj3) {
40768 {
40769 arg4 = wxString_in_helper(obj3);
40770 if (arg4 == NULL) SWIG_fail;
40771 temp4 = true;
40772 }
40773 }
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 {
40781 resultobj = wxPyMake_wxObject(result, (bool)0);
40782 }
40783 {
40784 if (temp3)
40785 delete arg3;
40786 }
40787 {
40788 if (temp4)
40789 delete arg4;
40790 }
40791 return resultobj;
40792 fail:
40793 {
40794 if (temp3)
40795 delete arg3;
40796 }
40797 {
40798 if (temp4)
40799 delete arg4;
40800 }
40801 return NULL;
40802 }
40803
40804
40805 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40806 PyObject *resultobj = 0;
40807 wxMenu *arg1 = (wxMenu *) 0 ;
40808 int arg2 ;
40809 wxString *arg3 = 0 ;
40810 wxString const &arg4_defvalue = wxPyEmptyString ;
40811 wxString *arg4 = (wxString *) &arg4_defvalue ;
40812 wxMenuItem *result = 0 ;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 int val2 ;
40816 int ecode2 = 0 ;
40817 bool temp3 = false ;
40818 bool temp4 = false ;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 PyObject * obj2 = 0 ;
40822 PyObject * obj3 = 0 ;
40823 char * kwnames[] = {
40824 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40825 };
40826
40827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40829 if (!SWIG_IsOK(res1)) {
40830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40831 }
40832 arg1 = reinterpret_cast< wxMenu * >(argp1);
40833 ecode2 = SWIG_AsVal_int(obj1, &val2);
40834 if (!SWIG_IsOK(ecode2)) {
40835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40836 }
40837 arg2 = static_cast< int >(val2);
40838 {
40839 arg3 = wxString_in_helper(obj2);
40840 if (arg3 == NULL) SWIG_fail;
40841 temp3 = true;
40842 }
40843 if (obj3) {
40844 {
40845 arg4 = wxString_in_helper(obj3);
40846 if (arg4 == NULL) SWIG_fail;
40847 temp4 = true;
40848 }
40849 }
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = wxPyMake_wxObject(result, (bool)0);
40858 }
40859 {
40860 if (temp3)
40861 delete arg3;
40862 }
40863 {
40864 if (temp4)
40865 delete arg4;
40866 }
40867 return resultobj;
40868 fail:
40869 {
40870 if (temp3)
40871 delete arg3;
40872 }
40873 {
40874 if (temp4)
40875 delete arg4;
40876 }
40877 return NULL;
40878 }
40879
40880
40881 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40882 PyObject *resultobj = 0;
40883 wxMenu *arg1 = (wxMenu *) 0 ;
40884 int arg2 ;
40885 wxString *arg3 = 0 ;
40886 wxMenu *arg4 = (wxMenu *) 0 ;
40887 wxString const &arg5_defvalue = wxPyEmptyString ;
40888 wxString *arg5 = (wxString *) &arg5_defvalue ;
40889 wxMenuItem *result = 0 ;
40890 void *argp1 = 0 ;
40891 int res1 = 0 ;
40892 int val2 ;
40893 int ecode2 = 0 ;
40894 bool temp3 = false ;
40895 void *argp4 = 0 ;
40896 int res4 = 0 ;
40897 bool temp5 = false ;
40898 PyObject * obj0 = 0 ;
40899 PyObject * obj1 = 0 ;
40900 PyObject * obj2 = 0 ;
40901 PyObject * obj3 = 0 ;
40902 PyObject * obj4 = 0 ;
40903 char * kwnames[] = {
40904 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40905 };
40906
40907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40909 if (!SWIG_IsOK(res1)) {
40910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40911 }
40912 arg1 = reinterpret_cast< wxMenu * >(argp1);
40913 ecode2 = SWIG_AsVal_int(obj1, &val2);
40914 if (!SWIG_IsOK(ecode2)) {
40915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40916 }
40917 arg2 = static_cast< int >(val2);
40918 {
40919 arg3 = wxString_in_helper(obj2);
40920 if (arg3 == NULL) SWIG_fail;
40921 temp3 = true;
40922 }
40923 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40924 if (!SWIG_IsOK(res4)) {
40925 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40926 }
40927 arg4 = reinterpret_cast< wxMenu * >(argp4);
40928 if (obj4) {
40929 {
40930 arg5 = wxString_in_helper(obj4);
40931 if (arg5 == NULL) SWIG_fail;
40932 temp5 = true;
40933 }
40934 }
40935 {
40936 PyThreadState* __tstate = wxPyBeginAllowThreads();
40937 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 resultobj = wxPyMake_wxObject(result, (bool)0);
40943 }
40944 {
40945 if (temp3)
40946 delete arg3;
40947 }
40948 {
40949 if (temp5)
40950 delete arg5;
40951 }
40952 return resultobj;
40953 fail:
40954 {
40955 if (temp3)
40956 delete arg3;
40957 }
40958 {
40959 if (temp5)
40960 delete arg5;
40961 }
40962 return NULL;
40963 }
40964
40965
40966 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj = 0;
40968 wxMenu *arg1 = (wxMenu *) 0 ;
40969 int arg2 ;
40970 wxMenuItem *result = 0 ;
40971 void *argp1 = 0 ;
40972 int res1 = 0 ;
40973 int val2 ;
40974 int ecode2 = 0 ;
40975 PyObject * obj0 = 0 ;
40976 PyObject * obj1 = 0 ;
40977 char * kwnames[] = {
40978 (char *) "self",(char *) "id", NULL
40979 };
40980
40981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40983 if (!SWIG_IsOK(res1)) {
40984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40985 }
40986 arg1 = reinterpret_cast< wxMenu * >(argp1);
40987 ecode2 = SWIG_AsVal_int(obj1, &val2);
40988 if (!SWIG_IsOK(ecode2)) {
40989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40990 }
40991 arg2 = static_cast< int >(val2);
40992 {
40993 PyThreadState* __tstate = wxPyBeginAllowThreads();
40994 result = (wxMenuItem *)(arg1)->Remove(arg2);
40995 wxPyEndAllowThreads(__tstate);
40996 if (PyErr_Occurred()) SWIG_fail;
40997 }
40998 {
40999 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41000 }
41001 return resultobj;
41002 fail:
41003 return NULL;
41004 }
41005
41006
41007 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41008 PyObject *resultobj = 0;
41009 wxMenu *arg1 = (wxMenu *) 0 ;
41010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41011 wxMenuItem *result = 0 ;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 void *argp2 = 0 ;
41015 int res2 = 0 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "self",(char *) "item", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
41023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41026 }
41027 arg1 = reinterpret_cast< wxMenu * >(argp1);
41028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41029 if (!SWIG_IsOK(res2)) {
41030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41031 }
41032 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41033 {
41034 PyThreadState* __tstate = wxPyBeginAllowThreads();
41035 result = (wxMenuItem *)(arg1)->Remove(arg2);
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 {
41040 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41041 }
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj = 0;
41050 wxMenu *arg1 = (wxMenu *) 0 ;
41051 int arg2 ;
41052 bool result;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 int val2 ;
41056 int ecode2 = 0 ;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 char * kwnames[] = {
41060 (char *) "self",(char *) "id", NULL
41061 };
41062
41063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenu * >(argp1);
41069 ecode2 = SWIG_AsVal_int(obj1, &val2);
41070 if (!SWIG_IsOK(ecode2)) {
41071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41072 }
41073 arg2 = static_cast< int >(val2);
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (bool)(arg1)->Delete(arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41082 }
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj = 0;
41091 wxMenu *arg1 = (wxMenu *) 0 ;
41092 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41093 bool result;
41094 void *argp1 = 0 ;
41095 int res1 = 0 ;
41096 void *argp2 = 0 ;
41097 int res2 = 0 ;
41098 PyObject * obj0 = 0 ;
41099 PyObject * obj1 = 0 ;
41100 char * kwnames[] = {
41101 (char *) "self",(char *) "item", NULL
41102 };
41103
41104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41106 if (!SWIG_IsOK(res1)) {
41107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41108 }
41109 arg1 = reinterpret_cast< wxMenu * >(argp1);
41110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41111 if (!SWIG_IsOK(res2)) {
41112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41113 }
41114 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41115 {
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 result = (bool)(arg1)->Delete(arg2);
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 {
41122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41123 }
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41131 PyObject *resultobj = 0;
41132 wxMenu *arg1 = (wxMenu *) 0 ;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 PyObject *swig_obj[1] ;
41136
41137 if (!args) SWIG_fail;
41138 swig_obj[0] = args;
41139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41140 if (!SWIG_IsOK(res1)) {
41141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41142 }
41143 arg1 = reinterpret_cast< wxMenu * >(argp1);
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 wxMenu_Destroy(arg1);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 resultobj = SWIG_Py_Void();
41151 return resultobj;
41152 fail:
41153 return NULL;
41154 }
41155
41156
41157 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41158 PyObject *resultobj = 0;
41159 wxMenu *arg1 = (wxMenu *) 0 ;
41160 int arg2 ;
41161 bool result;
41162 void *argp1 = 0 ;
41163 int res1 = 0 ;
41164 int val2 ;
41165 int ecode2 = 0 ;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char * kwnames[] = {
41169 (char *) "self",(char *) "id", NULL
41170 };
41171
41172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41174 if (!SWIG_IsOK(res1)) {
41175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41176 }
41177 arg1 = reinterpret_cast< wxMenu * >(argp1);
41178 ecode2 = SWIG_AsVal_int(obj1, &val2);
41179 if (!SWIG_IsOK(ecode2)) {
41180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41181 }
41182 arg2 = static_cast< int >(val2);
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 result = (bool)(arg1)->Destroy(arg2);
41186 wxPyEndAllowThreads(__tstate);
41187 if (PyErr_Occurred()) SWIG_fail;
41188 }
41189 {
41190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41191 }
41192 return resultobj;
41193 fail:
41194 return NULL;
41195 }
41196
41197
41198 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj = 0;
41200 wxMenu *arg1 = (wxMenu *) 0 ;
41201 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41202 bool result;
41203 void *argp1 = 0 ;
41204 int res1 = 0 ;
41205 void *argp2 = 0 ;
41206 int res2 = 0 ;
41207 PyObject * obj0 = 0 ;
41208 PyObject * obj1 = 0 ;
41209 char * kwnames[] = {
41210 (char *) "self",(char *) "item", NULL
41211 };
41212
41213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41215 if (!SWIG_IsOK(res1)) {
41216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41217 }
41218 arg1 = reinterpret_cast< wxMenu * >(argp1);
41219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41220 if (!SWIG_IsOK(res2)) {
41221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41222 }
41223 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = (bool)(arg1)->Destroy(arg2);
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 {
41231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41232 }
41233 return resultobj;
41234 fail:
41235 return NULL;
41236 }
41237
41238
41239 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41240 PyObject *resultobj = 0;
41241 wxMenu *arg1 = (wxMenu *) 0 ;
41242 size_t result;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 PyObject *swig_obj[1] ;
41246
41247 if (!args) SWIG_fail;
41248 swig_obj[0] = args;
41249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenu * >(argp1);
41254 {
41255 PyThreadState* __tstate = wxPyBeginAllowThreads();
41256 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41257 wxPyEndAllowThreads(__tstate);
41258 if (PyErr_Occurred()) SWIG_fail;
41259 }
41260 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41261 return resultobj;
41262 fail:
41263 return NULL;
41264 }
41265
41266
41267 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41268 PyObject *resultobj = 0;
41269 wxMenu *arg1 = (wxMenu *) 0 ;
41270 PyObject *result = 0 ;
41271 void *argp1 = 0 ;
41272 int res1 = 0 ;
41273 PyObject *swig_obj[1] ;
41274
41275 if (!args) SWIG_fail;
41276 swig_obj[0] = args;
41277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41278 if (!SWIG_IsOK(res1)) {
41279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41280 }
41281 arg1 = reinterpret_cast< wxMenu * >(argp1);
41282 {
41283 PyThreadState* __tstate = wxPyBeginAllowThreads();
41284 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 resultobj = result;
41289 return resultobj;
41290 fail:
41291 return NULL;
41292 }
41293
41294
41295 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj = 0;
41297 wxMenu *arg1 = (wxMenu *) 0 ;
41298 wxString *arg2 = 0 ;
41299 int result;
41300 void *argp1 = 0 ;
41301 int res1 = 0 ;
41302 bool temp2 = false ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 char * kwnames[] = {
41306 (char *) "self",(char *) "item", NULL
41307 };
41308
41309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41311 if (!SWIG_IsOK(res1)) {
41312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41313 }
41314 arg1 = reinterpret_cast< wxMenu * >(argp1);
41315 {
41316 arg2 = wxString_in_helper(obj1);
41317 if (arg2 == NULL) SWIG_fail;
41318 temp2 = true;
41319 }
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 resultobj = SWIG_From_int(static_cast< int >(result));
41327 {
41328 if (temp2)
41329 delete arg2;
41330 }
41331 return resultobj;
41332 fail:
41333 {
41334 if (temp2)
41335 delete arg2;
41336 }
41337 return NULL;
41338 }
41339
41340
41341 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41342 PyObject *resultobj = 0;
41343 wxMenu *arg1 = (wxMenu *) 0 ;
41344 int arg2 ;
41345 wxMenuItem *result = 0 ;
41346 void *argp1 = 0 ;
41347 int res1 = 0 ;
41348 int val2 ;
41349 int ecode2 = 0 ;
41350 PyObject * obj0 = 0 ;
41351 PyObject * obj1 = 0 ;
41352 char * kwnames[] = {
41353 (char *) "self",(char *) "id", NULL
41354 };
41355
41356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41358 if (!SWIG_IsOK(res1)) {
41359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41360 }
41361 arg1 = reinterpret_cast< wxMenu * >(argp1);
41362 ecode2 = SWIG_AsVal_int(obj1, &val2);
41363 if (!SWIG_IsOK(ecode2)) {
41364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41365 }
41366 arg2 = static_cast< int >(val2);
41367 {
41368 PyThreadState* __tstate = wxPyBeginAllowThreads();
41369 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41370 wxPyEndAllowThreads(__tstate);
41371 if (PyErr_Occurred()) SWIG_fail;
41372 }
41373 {
41374 resultobj = wxPyMake_wxObject(result, (bool)0);
41375 }
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj = 0;
41384 wxMenu *arg1 = (wxMenu *) 0 ;
41385 size_t arg2 ;
41386 wxMenuItem *result = 0 ;
41387 void *argp1 = 0 ;
41388 int res1 = 0 ;
41389 size_t val2 ;
41390 int ecode2 = 0 ;
41391 PyObject * obj0 = 0 ;
41392 PyObject * obj1 = 0 ;
41393 char * kwnames[] = {
41394 (char *) "self",(char *) "position", NULL
41395 };
41396
41397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41401 }
41402 arg1 = reinterpret_cast< wxMenu * >(argp1);
41403 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41404 if (!SWIG_IsOK(ecode2)) {
41405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41406 }
41407 arg2 = static_cast< size_t >(val2);
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41411 wxPyEndAllowThreads(__tstate);
41412 if (PyErr_Occurred()) SWIG_fail;
41413 }
41414 {
41415 resultobj = wxPyMake_wxObject(result, (bool)0);
41416 }
41417 return resultobj;
41418 fail:
41419 return NULL;
41420 }
41421
41422
41423 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41424 PyObject *resultobj = 0;
41425 wxMenu *arg1 = (wxMenu *) 0 ;
41426 int arg2 ;
41427 bool arg3 ;
41428 void *argp1 = 0 ;
41429 int res1 = 0 ;
41430 int val2 ;
41431 int ecode2 = 0 ;
41432 bool val3 ;
41433 int ecode3 = 0 ;
41434 PyObject * obj0 = 0 ;
41435 PyObject * obj1 = 0 ;
41436 PyObject * obj2 = 0 ;
41437 char * kwnames[] = {
41438 (char *) "self",(char *) "id",(char *) "enable", NULL
41439 };
41440
41441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41443 if (!SWIG_IsOK(res1)) {
41444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41445 }
41446 arg1 = reinterpret_cast< wxMenu * >(argp1);
41447 ecode2 = SWIG_AsVal_int(obj1, &val2);
41448 if (!SWIG_IsOK(ecode2)) {
41449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41450 }
41451 arg2 = static_cast< int >(val2);
41452 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41453 if (!SWIG_IsOK(ecode3)) {
41454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41455 }
41456 arg3 = static_cast< bool >(val3);
41457 {
41458 PyThreadState* __tstate = wxPyBeginAllowThreads();
41459 (arg1)->Enable(arg2,arg3);
41460 wxPyEndAllowThreads(__tstate);
41461 if (PyErr_Occurred()) SWIG_fail;
41462 }
41463 resultobj = SWIG_Py_Void();
41464 return resultobj;
41465 fail:
41466 return NULL;
41467 }
41468
41469
41470 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41471 PyObject *resultobj = 0;
41472 wxMenu *arg1 = (wxMenu *) 0 ;
41473 int arg2 ;
41474 bool result;
41475 void *argp1 = 0 ;
41476 int res1 = 0 ;
41477 int val2 ;
41478 int ecode2 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 PyObject * obj1 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "self",(char *) "id", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41487 if (!SWIG_IsOK(res1)) {
41488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41489 }
41490 arg1 = reinterpret_cast< wxMenu * >(argp1);
41491 ecode2 = SWIG_AsVal_int(obj1, &val2);
41492 if (!SWIG_IsOK(ecode2)) {
41493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41494 }
41495 arg2 = static_cast< int >(val2);
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 {
41503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41504 }
41505 return resultobj;
41506 fail:
41507 return NULL;
41508 }
41509
41510
41511 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj = 0;
41513 wxMenu *arg1 = (wxMenu *) 0 ;
41514 int arg2 ;
41515 bool arg3 ;
41516 void *argp1 = 0 ;
41517 int res1 = 0 ;
41518 int val2 ;
41519 int ecode2 = 0 ;
41520 bool val3 ;
41521 int ecode3 = 0 ;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 PyObject * obj2 = 0 ;
41525 char * kwnames[] = {
41526 (char *) "self",(char *) "id",(char *) "check", NULL
41527 };
41528
41529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41531 if (!SWIG_IsOK(res1)) {
41532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41533 }
41534 arg1 = reinterpret_cast< wxMenu * >(argp1);
41535 ecode2 = SWIG_AsVal_int(obj1, &val2);
41536 if (!SWIG_IsOK(ecode2)) {
41537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41538 }
41539 arg2 = static_cast< int >(val2);
41540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41541 if (!SWIG_IsOK(ecode3)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41543 }
41544 arg3 = static_cast< bool >(val3);
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 (arg1)->Check(arg2,arg3);
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 resultobj = SWIG_Py_Void();
41552 return resultobj;
41553 fail:
41554 return NULL;
41555 }
41556
41557
41558 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41559 PyObject *resultobj = 0;
41560 wxMenu *arg1 = (wxMenu *) 0 ;
41561 int arg2 ;
41562 bool result;
41563 void *argp1 = 0 ;
41564 int res1 = 0 ;
41565 int val2 ;
41566 int ecode2 = 0 ;
41567 PyObject * obj0 = 0 ;
41568 PyObject * obj1 = 0 ;
41569 char * kwnames[] = {
41570 (char *) "self",(char *) "id", NULL
41571 };
41572
41573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41575 if (!SWIG_IsOK(res1)) {
41576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41577 }
41578 arg1 = reinterpret_cast< wxMenu * >(argp1);
41579 ecode2 = SWIG_AsVal_int(obj1, &val2);
41580 if (!SWIG_IsOK(ecode2)) {
41581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41582 }
41583 arg2 = static_cast< int >(val2);
41584 {
41585 PyThreadState* __tstate = wxPyBeginAllowThreads();
41586 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41587 wxPyEndAllowThreads(__tstate);
41588 if (PyErr_Occurred()) SWIG_fail;
41589 }
41590 {
41591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41592 }
41593 return resultobj;
41594 fail:
41595 return NULL;
41596 }
41597
41598
41599 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41600 PyObject *resultobj = 0;
41601 wxMenu *arg1 = (wxMenu *) 0 ;
41602 int arg2 ;
41603 wxString *arg3 = 0 ;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 int val2 ;
41607 int ecode2 = 0 ;
41608 bool temp3 = false ;
41609 PyObject * obj0 = 0 ;
41610 PyObject * obj1 = 0 ;
41611 PyObject * obj2 = 0 ;
41612 char * kwnames[] = {
41613 (char *) "self",(char *) "id",(char *) "label", NULL
41614 };
41615
41616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41618 if (!SWIG_IsOK(res1)) {
41619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41620 }
41621 arg1 = reinterpret_cast< wxMenu * >(argp1);
41622 ecode2 = SWIG_AsVal_int(obj1, &val2);
41623 if (!SWIG_IsOK(ecode2)) {
41624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41625 }
41626 arg2 = static_cast< int >(val2);
41627 {
41628 arg3 = wxString_in_helper(obj2);
41629 if (arg3 == NULL) SWIG_fail;
41630 temp3 = true;
41631 }
41632 {
41633 PyThreadState* __tstate = wxPyBeginAllowThreads();
41634 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41635 wxPyEndAllowThreads(__tstate);
41636 if (PyErr_Occurred()) SWIG_fail;
41637 }
41638 resultobj = SWIG_Py_Void();
41639 {
41640 if (temp3)
41641 delete arg3;
41642 }
41643 return resultobj;
41644 fail:
41645 {
41646 if (temp3)
41647 delete arg3;
41648 }
41649 return NULL;
41650 }
41651
41652
41653 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj = 0;
41655 wxMenu *arg1 = (wxMenu *) 0 ;
41656 int arg2 ;
41657 wxString result;
41658 void *argp1 = 0 ;
41659 int res1 = 0 ;
41660 int val2 ;
41661 int ecode2 = 0 ;
41662 PyObject * obj0 = 0 ;
41663 PyObject * obj1 = 0 ;
41664 char * kwnames[] = {
41665 (char *) "self",(char *) "id", NULL
41666 };
41667
41668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41670 if (!SWIG_IsOK(res1)) {
41671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41672 }
41673 arg1 = reinterpret_cast< wxMenu * >(argp1);
41674 ecode2 = SWIG_AsVal_int(obj1, &val2);
41675 if (!SWIG_IsOK(ecode2)) {
41676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41677 }
41678 arg2 = static_cast< int >(val2);
41679 {
41680 PyThreadState* __tstate = wxPyBeginAllowThreads();
41681 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41682 wxPyEndAllowThreads(__tstate);
41683 if (PyErr_Occurred()) SWIG_fail;
41684 }
41685 {
41686 #if wxUSE_UNICODE
41687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41688 #else
41689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41690 #endif
41691 }
41692 return resultobj;
41693 fail:
41694 return NULL;
41695 }
41696
41697
41698 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj = 0;
41700 wxMenu *arg1 = (wxMenu *) 0 ;
41701 int arg2 ;
41702 wxString *arg3 = 0 ;
41703 void *argp1 = 0 ;
41704 int res1 = 0 ;
41705 int val2 ;
41706 int ecode2 = 0 ;
41707 bool temp3 = false ;
41708 PyObject * obj0 = 0 ;
41709 PyObject * obj1 = 0 ;
41710 PyObject * obj2 = 0 ;
41711 char * kwnames[] = {
41712 (char *) "self",(char *) "id",(char *) "helpString", NULL
41713 };
41714
41715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41717 if (!SWIG_IsOK(res1)) {
41718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41719 }
41720 arg1 = reinterpret_cast< wxMenu * >(argp1);
41721 ecode2 = SWIG_AsVal_int(obj1, &val2);
41722 if (!SWIG_IsOK(ecode2)) {
41723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41724 }
41725 arg2 = static_cast< int >(val2);
41726 {
41727 arg3 = wxString_in_helper(obj2);
41728 if (arg3 == NULL) SWIG_fail;
41729 temp3 = true;
41730 }
41731 {
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_Py_Void();
41738 {
41739 if (temp3)
41740 delete arg3;
41741 }
41742 return resultobj;
41743 fail:
41744 {
41745 if (temp3)
41746 delete arg3;
41747 }
41748 return NULL;
41749 }
41750
41751
41752 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj = 0;
41754 wxMenu *arg1 = (wxMenu *) 0 ;
41755 int arg2 ;
41756 wxString result;
41757 void *argp1 = 0 ;
41758 int res1 = 0 ;
41759 int val2 ;
41760 int ecode2 = 0 ;
41761 PyObject * obj0 = 0 ;
41762 PyObject * obj1 = 0 ;
41763 char * kwnames[] = {
41764 (char *) "self",(char *) "id", NULL
41765 };
41766
41767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41769 if (!SWIG_IsOK(res1)) {
41770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41771 }
41772 arg1 = reinterpret_cast< wxMenu * >(argp1);
41773 ecode2 = SWIG_AsVal_int(obj1, &val2);
41774 if (!SWIG_IsOK(ecode2)) {
41775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41776 }
41777 arg2 = static_cast< int >(val2);
41778 {
41779 PyThreadState* __tstate = wxPyBeginAllowThreads();
41780 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41781 wxPyEndAllowThreads(__tstate);
41782 if (PyErr_Occurred()) SWIG_fail;
41783 }
41784 {
41785 #if wxUSE_UNICODE
41786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41787 #else
41788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41789 #endif
41790 }
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj = 0;
41799 wxMenu *arg1 = (wxMenu *) 0 ;
41800 wxString *arg2 = 0 ;
41801 void *argp1 = 0 ;
41802 int res1 = 0 ;
41803 bool temp2 = false ;
41804 PyObject * obj0 = 0 ;
41805 PyObject * obj1 = 0 ;
41806 char * kwnames[] = {
41807 (char *) "self",(char *) "title", NULL
41808 };
41809
41810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41812 if (!SWIG_IsOK(res1)) {
41813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41814 }
41815 arg1 = reinterpret_cast< wxMenu * >(argp1);
41816 {
41817 arg2 = wxString_in_helper(obj1);
41818 if (arg2 == NULL) SWIG_fail;
41819 temp2 = true;
41820 }
41821 {
41822 PyThreadState* __tstate = wxPyBeginAllowThreads();
41823 (arg1)->SetTitle((wxString const &)*arg2);
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 resultobj = SWIG_Py_Void();
41828 {
41829 if (temp2)
41830 delete arg2;
41831 }
41832 return resultobj;
41833 fail:
41834 {
41835 if (temp2)
41836 delete arg2;
41837 }
41838 return NULL;
41839 }
41840
41841
41842 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41843 PyObject *resultobj = 0;
41844 wxMenu *arg1 = (wxMenu *) 0 ;
41845 wxString result;
41846 void *argp1 = 0 ;
41847 int res1 = 0 ;
41848 PyObject *swig_obj[1] ;
41849
41850 if (!args) SWIG_fail;
41851 swig_obj[0] = args;
41852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41855 }
41856 arg1 = reinterpret_cast< wxMenu * >(argp1);
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 result = ((wxMenu const *)arg1)->GetTitle();
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 {
41864 #if wxUSE_UNICODE
41865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41866 #else
41867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41868 #endif
41869 }
41870 return resultobj;
41871 fail:
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41877 PyObject *resultobj = 0;
41878 wxMenu *arg1 = (wxMenu *) 0 ;
41879 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 void *argp2 = 0 ;
41883 int res2 = 0 ;
41884 PyObject * obj0 = 0 ;
41885 PyObject * obj1 = 0 ;
41886 char * kwnames[] = {
41887 (char *) "self",(char *) "handler", NULL
41888 };
41889
41890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenu * >(argp1);
41896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41897 if (!SWIG_IsOK(res2)) {
41898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41899 }
41900 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 (arg1)->SetEventHandler(arg2);
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 resultobj = SWIG_Py_Void();
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41915 PyObject *resultobj = 0;
41916 wxMenu *arg1 = (wxMenu *) 0 ;
41917 wxEvtHandler *result = 0 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 PyObject *swig_obj[1] ;
41921
41922 if (!args) SWIG_fail;
41923 swig_obj[0] = args;
41924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41925 if (!SWIG_IsOK(res1)) {
41926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41927 }
41928 arg1 = reinterpret_cast< wxMenu * >(argp1);
41929 {
41930 PyThreadState* __tstate = wxPyBeginAllowThreads();
41931 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41932 wxPyEndAllowThreads(__tstate);
41933 if (PyErr_Occurred()) SWIG_fail;
41934 }
41935 {
41936 resultobj = wxPyMake_wxObject(result, 0);
41937 }
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj = 0;
41946 wxMenu *arg1 = (wxMenu *) 0 ;
41947 wxWindow *arg2 = (wxWindow *) 0 ;
41948 void *argp1 = 0 ;
41949 int res1 = 0 ;
41950 void *argp2 = 0 ;
41951 int res2 = 0 ;
41952 PyObject * obj0 = 0 ;
41953 PyObject * obj1 = 0 ;
41954 char * kwnames[] = {
41955 (char *) "self",(char *) "win", NULL
41956 };
41957
41958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41960 if (!SWIG_IsOK(res1)) {
41961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41962 }
41963 arg1 = reinterpret_cast< wxMenu * >(argp1);
41964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41965 if (!SWIG_IsOK(res2)) {
41966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41967 }
41968 arg2 = reinterpret_cast< wxWindow * >(argp2);
41969 {
41970 PyThreadState* __tstate = wxPyBeginAllowThreads();
41971 (arg1)->SetInvokingWindow(arg2);
41972 wxPyEndAllowThreads(__tstate);
41973 if (PyErr_Occurred()) SWIG_fail;
41974 }
41975 resultobj = SWIG_Py_Void();
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41983 PyObject *resultobj = 0;
41984 wxMenu *arg1 = (wxMenu *) 0 ;
41985 wxWindow *result = 0 ;
41986 void *argp1 = 0 ;
41987 int res1 = 0 ;
41988 PyObject *swig_obj[1] ;
41989
41990 if (!args) SWIG_fail;
41991 swig_obj[0] = args;
41992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41995 }
41996 arg1 = reinterpret_cast< wxMenu * >(argp1);
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
42000 wxPyEndAllowThreads(__tstate);
42001 if (PyErr_Occurred()) SWIG_fail;
42002 }
42003 {
42004 resultobj = wxPyMake_wxObject(result, 0);
42005 }
42006 return resultobj;
42007 fail:
42008 return NULL;
42009 }
42010
42011
42012 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42013 PyObject *resultobj = 0;
42014 wxMenu *arg1 = (wxMenu *) 0 ;
42015 long result;
42016 void *argp1 = 0 ;
42017 int res1 = 0 ;
42018 PyObject *swig_obj[1] ;
42019
42020 if (!args) SWIG_fail;
42021 swig_obj[0] = args;
42022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42023 if (!SWIG_IsOK(res1)) {
42024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
42025 }
42026 arg1 = reinterpret_cast< wxMenu * >(argp1);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (long)((wxMenu const *)arg1)->GetStyle();
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_From_long(static_cast< long >(result));
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42041 PyObject *resultobj = 0;
42042 wxMenu *arg1 = (wxMenu *) 0 ;
42043 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42044 void *argp1 = 0 ;
42045 int res1 = 0 ;
42046 void *argp2 = 0 ;
42047 int res2 = 0 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 char * kwnames[] = {
42051 (char *) "self",(char *) "source", NULL
42052 };
42053
42054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42056 if (!SWIG_IsOK(res1)) {
42057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42058 }
42059 arg1 = reinterpret_cast< wxMenu * >(argp1);
42060 if (obj1) {
42061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42062 if (!SWIG_IsOK(res2)) {
42063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42064 }
42065 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42066 }
42067 {
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 (arg1)->UpdateUI(arg2);
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 resultobj = SWIG_Py_Void();
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42081 PyObject *resultobj = 0;
42082 wxMenu *arg1 = (wxMenu *) 0 ;
42083 wxMenuBar *result = 0 ;
42084 void *argp1 = 0 ;
42085 int res1 = 0 ;
42086 PyObject *swig_obj[1] ;
42087
42088 if (!args) SWIG_fail;
42089 swig_obj[0] = args;
42090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenu * >(argp1);
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 {
42102 resultobj = wxPyMake_wxObject(result, (bool)0);
42103 }
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42111 PyObject *resultobj = 0;
42112 wxMenu *arg1 = (wxMenu *) 0 ;
42113 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42114 void *argp1 = 0 ;
42115 int res1 = 0 ;
42116 void *argp2 = 0 ;
42117 int res2 = 0 ;
42118 PyObject * obj0 = 0 ;
42119 PyObject * obj1 = 0 ;
42120 char * kwnames[] = {
42121 (char *) "self",(char *) "menubar", NULL
42122 };
42123
42124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42126 if (!SWIG_IsOK(res1)) {
42127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42128 }
42129 arg1 = reinterpret_cast< wxMenu * >(argp1);
42130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42131 if (!SWIG_IsOK(res2)) {
42132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42133 }
42134 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42135 {
42136 PyThreadState* __tstate = wxPyBeginAllowThreads();
42137 (arg1)->Attach(arg2);
42138 wxPyEndAllowThreads(__tstate);
42139 if (PyErr_Occurred()) SWIG_fail;
42140 }
42141 resultobj = SWIG_Py_Void();
42142 return resultobj;
42143 fail:
42144 return NULL;
42145 }
42146
42147
42148 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42149 PyObject *resultobj = 0;
42150 wxMenu *arg1 = (wxMenu *) 0 ;
42151 void *argp1 = 0 ;
42152 int res1 = 0 ;
42153 PyObject *swig_obj[1] ;
42154
42155 if (!args) SWIG_fail;
42156 swig_obj[0] = args;
42157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42158 if (!SWIG_IsOK(res1)) {
42159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42160 }
42161 arg1 = reinterpret_cast< wxMenu * >(argp1);
42162 {
42163 PyThreadState* __tstate = wxPyBeginAllowThreads();
42164 (arg1)->Detach();
42165 wxPyEndAllowThreads(__tstate);
42166 if (PyErr_Occurred()) SWIG_fail;
42167 }
42168 resultobj = SWIG_Py_Void();
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42176 PyObject *resultobj = 0;
42177 wxMenu *arg1 = (wxMenu *) 0 ;
42178 bool result;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 PyObject *swig_obj[1] ;
42182
42183 if (!args) SWIG_fail;
42184 swig_obj[0] = args;
42185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42186 if (!SWIG_IsOK(res1)) {
42187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42188 }
42189 arg1 = reinterpret_cast< wxMenu * >(argp1);
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 result = (bool)((wxMenu const *)arg1)->IsAttached();
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 {
42197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42198 }
42199 return resultobj;
42200 fail:
42201 return NULL;
42202 }
42203
42204
42205 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42206 PyObject *resultobj = 0;
42207 wxMenu *arg1 = (wxMenu *) 0 ;
42208 wxMenu *arg2 = (wxMenu *) 0 ;
42209 void *argp1 = 0 ;
42210 int res1 = 0 ;
42211 void *argp2 = 0 ;
42212 int res2 = 0 ;
42213 PyObject * obj0 = 0 ;
42214 PyObject * obj1 = 0 ;
42215 char * kwnames[] = {
42216 (char *) "self",(char *) "parent", NULL
42217 };
42218
42219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42221 if (!SWIG_IsOK(res1)) {
42222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42223 }
42224 arg1 = reinterpret_cast< wxMenu * >(argp1);
42225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42226 if (!SWIG_IsOK(res2)) {
42227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42228 }
42229 arg2 = reinterpret_cast< wxMenu * >(argp2);
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 (arg1)->SetParent(arg2);
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 resultobj = SWIG_Py_Void();
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42244 PyObject *resultobj = 0;
42245 wxMenu *arg1 = (wxMenu *) 0 ;
42246 wxMenu *result = 0 ;
42247 void *argp1 = 0 ;
42248 int res1 = 0 ;
42249 PyObject *swig_obj[1] ;
42250
42251 if (!args) SWIG_fail;
42252 swig_obj[0] = args;
42253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42254 if (!SWIG_IsOK(res1)) {
42255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42256 }
42257 arg1 = reinterpret_cast< wxMenu * >(argp1);
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 {
42265 resultobj = wxPyMake_wxObject(result, 0);
42266 }
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42274 PyObject *obj;
42275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42276 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42277 return SWIG_Py_Void();
42278 }
42279
42280 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 return SWIG_Python_InitShadowInstance(args);
42282 }
42283
42284 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42285 PyObject *resultobj = 0;
42286 long arg1 = (long) 0 ;
42287 wxMenuBar *result = 0 ;
42288 long val1 ;
42289 int ecode1 = 0 ;
42290 PyObject * obj0 = 0 ;
42291 char * kwnames[] = {
42292 (char *) "style", NULL
42293 };
42294
42295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42296 if (obj0) {
42297 ecode1 = SWIG_AsVal_long(obj0, &val1);
42298 if (!SWIG_IsOK(ecode1)) {
42299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42300 }
42301 arg1 = static_cast< long >(val1);
42302 }
42303 {
42304 if (!wxPyCheckForApp()) SWIG_fail;
42305 PyThreadState* __tstate = wxPyBeginAllowThreads();
42306 result = (wxMenuBar *)new wxMenuBar(arg1);
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj = 0;
42319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42320 wxMenu *arg2 = (wxMenu *) 0 ;
42321 wxString *arg3 = 0 ;
42322 bool result;
42323 void *argp1 = 0 ;
42324 int res1 = 0 ;
42325 void *argp2 = 0 ;
42326 int res2 = 0 ;
42327 bool temp3 = false ;
42328 PyObject * obj0 = 0 ;
42329 PyObject * obj1 = 0 ;
42330 PyObject * obj2 = 0 ;
42331 char * kwnames[] = {
42332 (char *) "self",(char *) "menu",(char *) "title", NULL
42333 };
42334
42335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42337 if (!SWIG_IsOK(res1)) {
42338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42339 }
42340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42342 if (!SWIG_IsOK(res2)) {
42343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42344 }
42345 arg2 = reinterpret_cast< wxMenu * >(argp2);
42346 {
42347 arg3 = wxString_in_helper(obj2);
42348 if (arg3 == NULL) SWIG_fail;
42349 temp3 = true;
42350 }
42351 {
42352 PyThreadState* __tstate = wxPyBeginAllowThreads();
42353 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42354 wxPyEndAllowThreads(__tstate);
42355 if (PyErr_Occurred()) SWIG_fail;
42356 }
42357 {
42358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42359 }
42360 {
42361 if (temp3)
42362 delete arg3;
42363 }
42364 return resultobj;
42365 fail:
42366 {
42367 if (temp3)
42368 delete arg3;
42369 }
42370 return NULL;
42371 }
42372
42373
42374 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42375 PyObject *resultobj = 0;
42376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42377 size_t arg2 ;
42378 wxMenu *arg3 = (wxMenu *) 0 ;
42379 wxString *arg4 = 0 ;
42380 bool result;
42381 void *argp1 = 0 ;
42382 int res1 = 0 ;
42383 size_t val2 ;
42384 int ecode2 = 0 ;
42385 void *argp3 = 0 ;
42386 int res3 = 0 ;
42387 bool temp4 = false ;
42388 PyObject * obj0 = 0 ;
42389 PyObject * obj1 = 0 ;
42390 PyObject * obj2 = 0 ;
42391 PyObject * obj3 = 0 ;
42392 char * kwnames[] = {
42393 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42394 };
42395
42396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42398 if (!SWIG_IsOK(res1)) {
42399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42400 }
42401 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42403 if (!SWIG_IsOK(ecode2)) {
42404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42405 }
42406 arg2 = static_cast< size_t >(val2);
42407 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42408 if (!SWIG_IsOK(res3)) {
42409 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42410 }
42411 arg3 = reinterpret_cast< wxMenu * >(argp3);
42412 {
42413 arg4 = wxString_in_helper(obj3);
42414 if (arg4 == NULL) SWIG_fail;
42415 temp4 = true;
42416 }
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 {
42424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42425 }
42426 {
42427 if (temp4)
42428 delete arg4;
42429 }
42430 return resultobj;
42431 fail:
42432 {
42433 if (temp4)
42434 delete arg4;
42435 }
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42441 PyObject *resultobj = 0;
42442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42443 size_t result;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 PyObject *swig_obj[1] ;
42447
42448 if (!args) SWIG_fail;
42449 swig_obj[0] = args;
42450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42462 return resultobj;
42463 fail:
42464 return NULL;
42465 }
42466
42467
42468 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42469 PyObject *resultobj = 0;
42470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42471 size_t arg2 ;
42472 wxMenu *result = 0 ;
42473 void *argp1 = 0 ;
42474 int res1 = 0 ;
42475 size_t val2 ;
42476 int ecode2 = 0 ;
42477 PyObject * obj0 = 0 ;
42478 PyObject * obj1 = 0 ;
42479 char * kwnames[] = {
42480 (char *) "self",(char *) "pos", NULL
42481 };
42482
42483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42485 if (!SWIG_IsOK(res1)) {
42486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42487 }
42488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42490 if (!SWIG_IsOK(ecode2)) {
42491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42492 }
42493 arg2 = static_cast< size_t >(val2);
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 resultobj = wxPyMake_wxObject(result, 0);
42502 }
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42510 PyObject *resultobj = 0;
42511 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42512 size_t arg2 ;
42513 wxMenu *arg3 = (wxMenu *) 0 ;
42514 wxString *arg4 = 0 ;
42515 wxMenu *result = 0 ;
42516 void *argp1 = 0 ;
42517 int res1 = 0 ;
42518 size_t val2 ;
42519 int ecode2 = 0 ;
42520 void *argp3 = 0 ;
42521 int res3 = 0 ;
42522 bool temp4 = false ;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525 PyObject * obj2 = 0 ;
42526 PyObject * obj3 = 0 ;
42527 char * kwnames[] = {
42528 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42529 };
42530
42531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42533 if (!SWIG_IsOK(res1)) {
42534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42535 }
42536 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42537 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42538 if (!SWIG_IsOK(ecode2)) {
42539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42540 }
42541 arg2 = static_cast< size_t >(val2);
42542 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42543 if (!SWIG_IsOK(res3)) {
42544 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42545 }
42546 arg3 = reinterpret_cast< wxMenu * >(argp3);
42547 {
42548 arg4 = wxString_in_helper(obj3);
42549 if (arg4 == NULL) SWIG_fail;
42550 temp4 = true;
42551 }
42552 {
42553 PyThreadState* __tstate = wxPyBeginAllowThreads();
42554 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42555 wxPyEndAllowThreads(__tstate);
42556 if (PyErr_Occurred()) SWIG_fail;
42557 }
42558 {
42559 resultobj = wxPyMake_wxObject(result, 0);
42560 }
42561 {
42562 if (temp4)
42563 delete arg4;
42564 }
42565 return resultobj;
42566 fail:
42567 {
42568 if (temp4)
42569 delete arg4;
42570 }
42571 return NULL;
42572 }
42573
42574
42575 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42576 PyObject *resultobj = 0;
42577 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42578 size_t arg2 ;
42579 wxMenu *result = 0 ;
42580 void *argp1 = 0 ;
42581 int res1 = 0 ;
42582 size_t val2 ;
42583 int ecode2 = 0 ;
42584 PyObject * obj0 = 0 ;
42585 PyObject * obj1 = 0 ;
42586 char * kwnames[] = {
42587 (char *) "self",(char *) "pos", NULL
42588 };
42589
42590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42592 if (!SWIG_IsOK(res1)) {
42593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42594 }
42595 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42596 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42597 if (!SWIG_IsOK(ecode2)) {
42598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42599 }
42600 arg2 = static_cast< size_t >(val2);
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 result = (wxMenu *)(arg1)->Remove(arg2);
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 {
42608 resultobj = wxPyMake_wxObject(result, 0);
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42617 PyObject *resultobj = 0;
42618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42619 size_t arg2 ;
42620 bool arg3 ;
42621 void *argp1 = 0 ;
42622 int res1 = 0 ;
42623 size_t val2 ;
42624 int ecode2 = 0 ;
42625 bool val3 ;
42626 int ecode3 = 0 ;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629 PyObject * obj2 = 0 ;
42630 char * kwnames[] = {
42631 (char *) "self",(char *) "pos",(char *) "enable", NULL
42632 };
42633
42634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42636 if (!SWIG_IsOK(res1)) {
42637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42638 }
42639 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42640 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42641 if (!SWIG_IsOK(ecode2)) {
42642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42643 }
42644 arg2 = static_cast< size_t >(val2);
42645 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42646 if (!SWIG_IsOK(ecode3)) {
42647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42648 }
42649 arg3 = static_cast< bool >(val3);
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 (arg1)->EnableTop(arg2,arg3);
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_Py_Void();
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42664 PyObject *resultobj = 0;
42665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42666 size_t arg2 ;
42667 bool result;
42668 void *argp1 = 0 ;
42669 int res1 = 0 ;
42670 size_t val2 ;
42671 int ecode2 = 0 ;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674 char * kwnames[] = {
42675 (char *) "self",(char *) "pos", NULL
42676 };
42677
42678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42680 if (!SWIG_IsOK(res1)) {
42681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42682 }
42683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42685 if (!SWIG_IsOK(ecode2)) {
42686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42687 }
42688 arg2 = static_cast< size_t >(val2);
42689 {
42690 PyThreadState* __tstate = wxPyBeginAllowThreads();
42691 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42692 wxPyEndAllowThreads(__tstate);
42693 if (PyErr_Occurred()) SWIG_fail;
42694 }
42695 {
42696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42697 }
42698 return resultobj;
42699 fail:
42700 return NULL;
42701 }
42702
42703
42704 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42705 PyObject *resultobj = 0;
42706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42707 size_t arg2 ;
42708 wxString *arg3 = 0 ;
42709 void *argp1 = 0 ;
42710 int res1 = 0 ;
42711 size_t val2 ;
42712 int ecode2 = 0 ;
42713 bool temp3 = false ;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 PyObject * obj2 = 0 ;
42717 char * kwnames[] = {
42718 (char *) "self",(char *) "pos",(char *) "label", NULL
42719 };
42720
42721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42723 if (!SWIG_IsOK(res1)) {
42724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42725 }
42726 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42727 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42728 if (!SWIG_IsOK(ecode2)) {
42729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42730 }
42731 arg2 = static_cast< size_t >(val2);
42732 {
42733 arg3 = wxString_in_helper(obj2);
42734 if (arg3 == NULL) SWIG_fail;
42735 temp3 = true;
42736 }
42737 {
42738 PyThreadState* __tstate = wxPyBeginAllowThreads();
42739 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 resultobj = SWIG_Py_Void();
42744 {
42745 if (temp3)
42746 delete arg3;
42747 }
42748 return resultobj;
42749 fail:
42750 {
42751 if (temp3)
42752 delete arg3;
42753 }
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42759 PyObject *resultobj = 0;
42760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42761 size_t arg2 ;
42762 wxString result;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 size_t val2 ;
42766 int ecode2 = 0 ;
42767 PyObject * obj0 = 0 ;
42768 PyObject * obj1 = 0 ;
42769 char * kwnames[] = {
42770 (char *) "self",(char *) "pos", NULL
42771 };
42772
42773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42775 if (!SWIG_IsOK(res1)) {
42776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42777 }
42778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42779 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42780 if (!SWIG_IsOK(ecode2)) {
42781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42782 }
42783 arg2 = static_cast< size_t >(val2);
42784 {
42785 PyThreadState* __tstate = wxPyBeginAllowThreads();
42786 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42787 wxPyEndAllowThreads(__tstate);
42788 if (PyErr_Occurred()) SWIG_fail;
42789 }
42790 {
42791 #if wxUSE_UNICODE
42792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42793 #else
42794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42795 #endif
42796 }
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42804 PyObject *resultobj = 0;
42805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42806 wxString *arg2 = 0 ;
42807 wxString *arg3 = 0 ;
42808 int result;
42809 void *argp1 = 0 ;
42810 int res1 = 0 ;
42811 bool temp2 = false ;
42812 bool temp3 = false ;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 PyObject * obj2 = 0 ;
42816 char * kwnames[] = {
42817 (char *) "self",(char *) "menu",(char *) "item", NULL
42818 };
42819
42820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42822 if (!SWIG_IsOK(res1)) {
42823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42824 }
42825 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42826 {
42827 arg2 = wxString_in_helper(obj1);
42828 if (arg2 == NULL) SWIG_fail;
42829 temp2 = true;
42830 }
42831 {
42832 arg3 = wxString_in_helper(obj2);
42833 if (arg3 == NULL) SWIG_fail;
42834 temp3 = true;
42835 }
42836 {
42837 PyThreadState* __tstate = wxPyBeginAllowThreads();
42838 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42839 wxPyEndAllowThreads(__tstate);
42840 if (PyErr_Occurred()) SWIG_fail;
42841 }
42842 resultobj = SWIG_From_int(static_cast< int >(result));
42843 {
42844 if (temp2)
42845 delete arg2;
42846 }
42847 {
42848 if (temp3)
42849 delete arg3;
42850 }
42851 return resultobj;
42852 fail:
42853 {
42854 if (temp2)
42855 delete arg2;
42856 }
42857 {
42858 if (temp3)
42859 delete arg3;
42860 }
42861 return NULL;
42862 }
42863
42864
42865 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42866 PyObject *resultobj = 0;
42867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42868 int arg2 ;
42869 wxMenuItem *result = 0 ;
42870 void *argp1 = 0 ;
42871 int res1 = 0 ;
42872 int val2 ;
42873 int ecode2 = 0 ;
42874 PyObject * obj0 = 0 ;
42875 PyObject * obj1 = 0 ;
42876 char * kwnames[] = {
42877 (char *) "self",(char *) "id", NULL
42878 };
42879
42880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42886 ecode2 = SWIG_AsVal_int(obj1, &val2);
42887 if (!SWIG_IsOK(ecode2)) {
42888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42889 }
42890 arg2 = static_cast< int >(val2);
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42894 wxPyEndAllowThreads(__tstate);
42895 if (PyErr_Occurred()) SWIG_fail;
42896 }
42897 {
42898 resultobj = wxPyMake_wxObject(result, (bool)0);
42899 }
42900 return resultobj;
42901 fail:
42902 return NULL;
42903 }
42904
42905
42906 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42907 PyObject *resultobj = 0;
42908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42909 wxString *arg2 = 0 ;
42910 int result;
42911 void *argp1 = 0 ;
42912 int res1 = 0 ;
42913 bool temp2 = false ;
42914 PyObject * obj0 = 0 ;
42915 PyObject * obj1 = 0 ;
42916 char * kwnames[] = {
42917 (char *) "self",(char *) "title", NULL
42918 };
42919
42920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42922 if (!SWIG_IsOK(res1)) {
42923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42924 }
42925 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42926 {
42927 arg2 = wxString_in_helper(obj1);
42928 if (arg2 == NULL) SWIG_fail;
42929 temp2 = true;
42930 }
42931 {
42932 PyThreadState* __tstate = wxPyBeginAllowThreads();
42933 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42934 wxPyEndAllowThreads(__tstate);
42935 if (PyErr_Occurred()) SWIG_fail;
42936 }
42937 resultobj = SWIG_From_int(static_cast< int >(result));
42938 {
42939 if (temp2)
42940 delete arg2;
42941 }
42942 return resultobj;
42943 fail:
42944 {
42945 if (temp2)
42946 delete arg2;
42947 }
42948 return NULL;
42949 }
42950
42951
42952 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42953 PyObject *resultobj = 0;
42954 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42955 int arg2 ;
42956 bool arg3 ;
42957 void *argp1 = 0 ;
42958 int res1 = 0 ;
42959 int val2 ;
42960 int ecode2 = 0 ;
42961 bool val3 ;
42962 int ecode3 = 0 ;
42963 PyObject * obj0 = 0 ;
42964 PyObject * obj1 = 0 ;
42965 PyObject * obj2 = 0 ;
42966 char * kwnames[] = {
42967 (char *) "self",(char *) "id",(char *) "enable", NULL
42968 };
42969
42970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42972 if (!SWIG_IsOK(res1)) {
42973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42974 }
42975 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42976 ecode2 = SWIG_AsVal_int(obj1, &val2);
42977 if (!SWIG_IsOK(ecode2)) {
42978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42979 }
42980 arg2 = static_cast< int >(val2);
42981 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42982 if (!SWIG_IsOK(ecode3)) {
42983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42984 }
42985 arg3 = static_cast< bool >(val3);
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 (arg1)->Enable(arg2,arg3);
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 resultobj = SWIG_Py_Void();
42993 return resultobj;
42994 fail:
42995 return NULL;
42996 }
42997
42998
42999 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43000 PyObject *resultobj = 0;
43001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43002 int arg2 ;
43003 bool arg3 ;
43004 void *argp1 = 0 ;
43005 int res1 = 0 ;
43006 int val2 ;
43007 int ecode2 = 0 ;
43008 bool val3 ;
43009 int ecode3 = 0 ;
43010 PyObject * obj0 = 0 ;
43011 PyObject * obj1 = 0 ;
43012 PyObject * obj2 = 0 ;
43013 char * kwnames[] = {
43014 (char *) "self",(char *) "id",(char *) "check", NULL
43015 };
43016
43017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43023 ecode2 = SWIG_AsVal_int(obj1, &val2);
43024 if (!SWIG_IsOK(ecode2)) {
43025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43026 }
43027 arg2 = static_cast< int >(val2);
43028 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43029 if (!SWIG_IsOK(ecode3)) {
43030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43031 }
43032 arg3 = static_cast< bool >(val3);
43033 {
43034 PyThreadState* __tstate = wxPyBeginAllowThreads();
43035 (arg1)->Check(arg2,arg3);
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 resultobj = SWIG_Py_Void();
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43047 PyObject *resultobj = 0;
43048 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43049 int arg2 ;
43050 bool result;
43051 void *argp1 = 0 ;
43052 int res1 = 0 ;
43053 int val2 ;
43054 int ecode2 = 0 ;
43055 PyObject * obj0 = 0 ;
43056 PyObject * obj1 = 0 ;
43057 char * kwnames[] = {
43058 (char *) "self",(char *) "id", NULL
43059 };
43060
43061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43067 ecode2 = SWIG_AsVal_int(obj1, &val2);
43068 if (!SWIG_IsOK(ecode2)) {
43069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43070 }
43071 arg2 = static_cast< int >(val2);
43072 {
43073 PyThreadState* __tstate = wxPyBeginAllowThreads();
43074 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43075 wxPyEndAllowThreads(__tstate);
43076 if (PyErr_Occurred()) SWIG_fail;
43077 }
43078 {
43079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43080 }
43081 return resultobj;
43082 fail:
43083 return NULL;
43084 }
43085
43086
43087 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43088 PyObject *resultobj = 0;
43089 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43090 int arg2 ;
43091 bool result;
43092 void *argp1 = 0 ;
43093 int res1 = 0 ;
43094 int val2 ;
43095 int ecode2 = 0 ;
43096 PyObject * obj0 = 0 ;
43097 PyObject * obj1 = 0 ;
43098 char * kwnames[] = {
43099 (char *) "self",(char *) "id", NULL
43100 };
43101
43102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43104 if (!SWIG_IsOK(res1)) {
43105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43106 }
43107 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43108 ecode2 = SWIG_AsVal_int(obj1, &val2);
43109 if (!SWIG_IsOK(ecode2)) {
43110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43111 }
43112 arg2 = static_cast< int >(val2);
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43116 wxPyEndAllowThreads(__tstate);
43117 if (PyErr_Occurred()) SWIG_fail;
43118 }
43119 {
43120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43121 }
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43129 PyObject *resultobj = 0;
43130 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43131 int arg2 ;
43132 wxString *arg3 = 0 ;
43133 void *argp1 = 0 ;
43134 int res1 = 0 ;
43135 int val2 ;
43136 int ecode2 = 0 ;
43137 bool temp3 = false ;
43138 PyObject * obj0 = 0 ;
43139 PyObject * obj1 = 0 ;
43140 PyObject * obj2 = 0 ;
43141 char * kwnames[] = {
43142 (char *) "self",(char *) "id",(char *) "label", NULL
43143 };
43144
43145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43147 if (!SWIG_IsOK(res1)) {
43148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43149 }
43150 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43151 ecode2 = SWIG_AsVal_int(obj1, &val2);
43152 if (!SWIG_IsOK(ecode2)) {
43153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43154 }
43155 arg2 = static_cast< int >(val2);
43156 {
43157 arg3 = wxString_in_helper(obj2);
43158 if (arg3 == NULL) SWIG_fail;
43159 temp3 = true;
43160 }
43161 {
43162 PyThreadState* __tstate = wxPyBeginAllowThreads();
43163 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43164 wxPyEndAllowThreads(__tstate);
43165 if (PyErr_Occurred()) SWIG_fail;
43166 }
43167 resultobj = SWIG_Py_Void();
43168 {
43169 if (temp3)
43170 delete arg3;
43171 }
43172 return resultobj;
43173 fail:
43174 {
43175 if (temp3)
43176 delete arg3;
43177 }
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43185 int arg2 ;
43186 wxString result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 int val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "id", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43203 ecode2 = SWIG_AsVal_int(obj1, &val2);
43204 if (!SWIG_IsOK(ecode2)) {
43205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43206 }
43207 arg2 = static_cast< int >(val2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 {
43215 #if wxUSE_UNICODE
43216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43217 #else
43218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43219 #endif
43220 }
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43228 PyObject *resultobj = 0;
43229 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43230 int arg2 ;
43231 wxString *arg3 = 0 ;
43232 void *argp1 = 0 ;
43233 int res1 = 0 ;
43234 int val2 ;
43235 int ecode2 = 0 ;
43236 bool temp3 = false ;
43237 PyObject * obj0 = 0 ;
43238 PyObject * obj1 = 0 ;
43239 PyObject * obj2 = 0 ;
43240 char * kwnames[] = {
43241 (char *) "self",(char *) "id",(char *) "helpString", NULL
43242 };
43243
43244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43246 if (!SWIG_IsOK(res1)) {
43247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43248 }
43249 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43250 ecode2 = SWIG_AsVal_int(obj1, &val2);
43251 if (!SWIG_IsOK(ecode2)) {
43252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43253 }
43254 arg2 = static_cast< int >(val2);
43255 {
43256 arg3 = wxString_in_helper(obj2);
43257 if (arg3 == NULL) SWIG_fail;
43258 temp3 = true;
43259 }
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43263 wxPyEndAllowThreads(__tstate);
43264 if (PyErr_Occurred()) SWIG_fail;
43265 }
43266 resultobj = SWIG_Py_Void();
43267 {
43268 if (temp3)
43269 delete arg3;
43270 }
43271 return resultobj;
43272 fail:
43273 {
43274 if (temp3)
43275 delete arg3;
43276 }
43277 return NULL;
43278 }
43279
43280
43281 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43282 PyObject *resultobj = 0;
43283 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43284 int arg2 ;
43285 wxString result;
43286 void *argp1 = 0 ;
43287 int res1 = 0 ;
43288 int val2 ;
43289 int ecode2 = 0 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 char * kwnames[] = {
43293 (char *) "self",(char *) "id", NULL
43294 };
43295
43296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43298 if (!SWIG_IsOK(res1)) {
43299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43300 }
43301 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43302 ecode2 = SWIG_AsVal_int(obj1, &val2);
43303 if (!SWIG_IsOK(ecode2)) {
43304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43305 }
43306 arg2 = static_cast< int >(val2);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 {
43314 #if wxUSE_UNICODE
43315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43316 #else
43317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43318 #endif
43319 }
43320 return resultobj;
43321 fail:
43322 return NULL;
43323 }
43324
43325
43326 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43327 PyObject *resultobj = 0;
43328 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43329 wxFrame *result = 0 ;
43330 void *argp1 = 0 ;
43331 int res1 = 0 ;
43332 PyObject *swig_obj[1] ;
43333
43334 if (!args) SWIG_fail;
43335 swig_obj[0] = args;
43336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 resultobj = wxPyMake_wxObject(result, (bool)0);
43349 }
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43357 PyObject *resultobj = 0;
43358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43359 bool result;
43360 void *argp1 = 0 ;
43361 int res1 = 0 ;
43362 PyObject *swig_obj[1] ;
43363
43364 if (!args) SWIG_fail;
43365 swig_obj[0] = args;
43366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43367 if (!SWIG_IsOK(res1)) {
43368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43369 }
43370 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 {
43378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43379 }
43380 return resultobj;
43381 fail:
43382 return NULL;
43383 }
43384
43385
43386 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43387 PyObject *resultobj = 0;
43388 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43389 wxFrame *arg2 = (wxFrame *) 0 ;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 void *argp2 = 0 ;
43393 int res2 = 0 ;
43394 PyObject * obj0 = 0 ;
43395 PyObject * obj1 = 0 ;
43396 char * kwnames[] = {
43397 (char *) "self",(char *) "frame", NULL
43398 };
43399
43400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43402 if (!SWIG_IsOK(res1)) {
43403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43404 }
43405 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43407 if (!SWIG_IsOK(res2)) {
43408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43409 }
43410 arg2 = reinterpret_cast< wxFrame * >(argp2);
43411 {
43412 PyThreadState* __tstate = wxPyBeginAllowThreads();
43413 (arg1)->Attach(arg2);
43414 wxPyEndAllowThreads(__tstate);
43415 if (PyErr_Occurred()) SWIG_fail;
43416 }
43417 resultobj = SWIG_Py_Void();
43418 return resultobj;
43419 fail:
43420 return NULL;
43421 }
43422
43423
43424 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43425 PyObject *resultobj = 0;
43426 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43427 void *argp1 = 0 ;
43428 int res1 = 0 ;
43429 PyObject *swig_obj[1] ;
43430
43431 if (!args) SWIG_fail;
43432 swig_obj[0] = args;
43433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43438 {
43439 PyThreadState* __tstate = wxPyBeginAllowThreads();
43440 (arg1)->Detach();
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = SWIG_Py_Void();
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43452 PyObject *resultobj = 0;
43453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43454 void *argp1 = 0 ;
43455 int res1 = 0 ;
43456 PyObject *swig_obj[1] ;
43457
43458 if (!args) SWIG_fail;
43459 swig_obj[0] = args;
43460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43461 if (!SWIG_IsOK(res1)) {
43462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43463 }
43464 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43465 {
43466 PyThreadState* __tstate = wxPyBeginAllowThreads();
43467 (arg1)->UpdateMenus();
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 resultobj = SWIG_Py_Void();
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43479 PyObject *resultobj = 0;
43480 bool arg1 ;
43481 bool val1 ;
43482 int ecode1 = 0 ;
43483 PyObject * obj0 = 0 ;
43484 char * kwnames[] = {
43485 (char *) "enable", NULL
43486 };
43487
43488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43489 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43490 if (!SWIG_IsOK(ecode1)) {
43491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43492 }
43493 arg1 = static_cast< bool >(val1);
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 wxMenuBar_SetAutoWindowMenu(arg1);
43497 wxPyEndAllowThreads(__tstate);
43498 if (PyErr_Occurred()) SWIG_fail;
43499 }
43500 resultobj = SWIG_Py_Void();
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43508 PyObject *resultobj = 0;
43509 bool result;
43510
43511 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 result = (bool)wxMenuBar_GetAutoWindowMenu();
43515 wxPyEndAllowThreads(__tstate);
43516 if (PyErr_Occurred()) SWIG_fail;
43517 }
43518 {
43519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43520 }
43521 return resultobj;
43522 fail:
43523 return NULL;
43524 }
43525
43526
43527 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43528 PyObject *obj;
43529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43530 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43531 return SWIG_Py_Void();
43532 }
43533
43534 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43535 return SWIG_Python_InitShadowInstance(args);
43536 }
43537
43538 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43539 PyObject *resultobj = 0;
43540 wxMenu *arg1 = (wxMenu *) NULL ;
43541 int arg2 = (int) wxID_ANY ;
43542 wxString const &arg3_defvalue = wxPyEmptyString ;
43543 wxString *arg3 = (wxString *) &arg3_defvalue ;
43544 wxString const &arg4_defvalue = wxPyEmptyString ;
43545 wxString *arg4 = (wxString *) &arg4_defvalue ;
43546 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43547 wxMenu *arg6 = (wxMenu *) NULL ;
43548 wxMenuItem *result = 0 ;
43549 void *argp1 = 0 ;
43550 int res1 = 0 ;
43551 int val2 ;
43552 int ecode2 = 0 ;
43553 bool temp3 = false ;
43554 bool temp4 = false ;
43555 int val5 ;
43556 int ecode5 = 0 ;
43557 void *argp6 = 0 ;
43558 int res6 = 0 ;
43559 PyObject * obj0 = 0 ;
43560 PyObject * obj1 = 0 ;
43561 PyObject * obj2 = 0 ;
43562 PyObject * obj3 = 0 ;
43563 PyObject * obj4 = 0 ;
43564 PyObject * obj5 = 0 ;
43565 char * kwnames[] = {
43566 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43567 };
43568
43569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43570 if (obj0) {
43571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43572 if (!SWIG_IsOK(res1)) {
43573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43574 }
43575 arg1 = reinterpret_cast< wxMenu * >(argp1);
43576 }
43577 if (obj1) {
43578 ecode2 = SWIG_AsVal_int(obj1, &val2);
43579 if (!SWIG_IsOK(ecode2)) {
43580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43581 }
43582 arg2 = static_cast< int >(val2);
43583 }
43584 if (obj2) {
43585 {
43586 arg3 = wxString_in_helper(obj2);
43587 if (arg3 == NULL) SWIG_fail;
43588 temp3 = true;
43589 }
43590 }
43591 if (obj3) {
43592 {
43593 arg4 = wxString_in_helper(obj3);
43594 if (arg4 == NULL) SWIG_fail;
43595 temp4 = true;
43596 }
43597 }
43598 if (obj4) {
43599 ecode5 = SWIG_AsVal_int(obj4, &val5);
43600 if (!SWIG_IsOK(ecode5)) {
43601 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43602 }
43603 arg5 = static_cast< wxItemKind >(val5);
43604 }
43605 if (obj5) {
43606 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43607 if (!SWIG_IsOK(res6)) {
43608 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43609 }
43610 arg6 = reinterpret_cast< wxMenu * >(argp6);
43611 }
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 {
43619 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43620 }
43621 {
43622 if (temp3)
43623 delete arg3;
43624 }
43625 {
43626 if (temp4)
43627 delete arg4;
43628 }
43629 return resultobj;
43630 fail:
43631 {
43632 if (temp3)
43633 delete arg3;
43634 }
43635 {
43636 if (temp4)
43637 delete arg4;
43638 }
43639 return NULL;
43640 }
43641
43642
43643 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43644 PyObject *resultobj = 0;
43645 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43646 void *argp1 = 0 ;
43647 int res1 = 0 ;
43648 PyObject *swig_obj[1] ;
43649
43650 if (!args) SWIG_fail;
43651 swig_obj[0] = args;
43652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43653 if (!SWIG_IsOK(res1)) {
43654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43655 }
43656 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 delete arg1;
43660
43661 wxPyEndAllowThreads(__tstate);
43662 if (PyErr_Occurred()) SWIG_fail;
43663 }
43664 resultobj = SWIG_Py_Void();
43665 return resultobj;
43666 fail:
43667 return NULL;
43668 }
43669
43670
43671 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43672 PyObject *resultobj = 0;
43673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43674 wxMenu *result = 0 ;
43675 void *argp1 = 0 ;
43676 int res1 = 0 ;
43677 PyObject *swig_obj[1] ;
43678
43679 if (!args) SWIG_fail;
43680 swig_obj[0] = args;
43681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43682 if (!SWIG_IsOK(res1)) {
43683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43684 }
43685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = wxPyMake_wxObject(result, 0);
43694 }
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj = 0;
43703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43704 wxMenu *arg2 = (wxMenu *) 0 ;
43705 void *argp1 = 0 ;
43706 int res1 = 0 ;
43707 void *argp2 = 0 ;
43708 int res2 = 0 ;
43709 PyObject * obj0 = 0 ;
43710 PyObject * obj1 = 0 ;
43711 char * kwnames[] = {
43712 (char *) "self",(char *) "menu", NULL
43713 };
43714
43715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43717 if (!SWIG_IsOK(res1)) {
43718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43719 }
43720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43722 if (!SWIG_IsOK(res2)) {
43723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43724 }
43725 arg2 = reinterpret_cast< wxMenu * >(argp2);
43726 {
43727 PyThreadState* __tstate = wxPyBeginAllowThreads();
43728 (arg1)->SetMenu(arg2);
43729 wxPyEndAllowThreads(__tstate);
43730 if (PyErr_Occurred()) SWIG_fail;
43731 }
43732 resultobj = SWIG_Py_Void();
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43740 PyObject *resultobj = 0;
43741 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43742 int arg2 ;
43743 void *argp1 = 0 ;
43744 int res1 = 0 ;
43745 int val2 ;
43746 int ecode2 = 0 ;
43747 PyObject * obj0 = 0 ;
43748 PyObject * obj1 = 0 ;
43749 char * kwnames[] = {
43750 (char *) "self",(char *) "id", NULL
43751 };
43752
43753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43759 ecode2 = SWIG_AsVal_int(obj1, &val2);
43760 if (!SWIG_IsOK(ecode2)) {
43761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43762 }
43763 arg2 = static_cast< int >(val2);
43764 {
43765 PyThreadState* __tstate = wxPyBeginAllowThreads();
43766 (arg1)->SetId(arg2);
43767 wxPyEndAllowThreads(__tstate);
43768 if (PyErr_Occurred()) SWIG_fail;
43769 }
43770 resultobj = SWIG_Py_Void();
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43778 PyObject *resultobj = 0;
43779 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43780 int result;
43781 void *argp1 = 0 ;
43782 int res1 = 0 ;
43783 PyObject *swig_obj[1] ;
43784
43785 if (!args) SWIG_fail;
43786 swig_obj[0] = args;
43787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43792 {
43793 PyThreadState* __tstate = wxPyBeginAllowThreads();
43794 result = (int)((wxMenuItem const *)arg1)->GetId();
43795 wxPyEndAllowThreads(__tstate);
43796 if (PyErr_Occurred()) SWIG_fail;
43797 }
43798 resultobj = SWIG_From_int(static_cast< int >(result));
43799 return resultobj;
43800 fail:
43801 return NULL;
43802 }
43803
43804
43805 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43806 PyObject *resultobj = 0;
43807 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43808 bool result;
43809 void *argp1 = 0 ;
43810 int res1 = 0 ;
43811 PyObject *swig_obj[1] ;
43812
43813 if (!args) SWIG_fail;
43814 swig_obj[0] = args;
43815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43816 if (!SWIG_IsOK(res1)) {
43817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43818 }
43819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43820 {
43821 PyThreadState* __tstate = wxPyBeginAllowThreads();
43822 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43823 wxPyEndAllowThreads(__tstate);
43824 if (PyErr_Occurred()) SWIG_fail;
43825 }
43826 {
43827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43828 }
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj = 0;
43837 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43838 wxString *arg2 = 0 ;
43839 void *argp1 = 0 ;
43840 int res1 = 0 ;
43841 bool temp2 = false ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "str", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43854 {
43855 arg2 = wxString_in_helper(obj1);
43856 if (arg2 == NULL) SWIG_fail;
43857 temp2 = true;
43858 }
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 (arg1)->SetText((wxString const &)*arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 resultobj = SWIG_Py_Void();
43866 {
43867 if (temp2)
43868 delete arg2;
43869 }
43870 return resultobj;
43871 fail:
43872 {
43873 if (temp2)
43874 delete arg2;
43875 }
43876 return NULL;
43877 }
43878
43879
43880 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43881 PyObject *resultobj = 0;
43882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43883 wxString result;
43884 void *argp1 = 0 ;
43885 int res1 = 0 ;
43886 PyObject *swig_obj[1] ;
43887
43888 if (!args) SWIG_fail;
43889 swig_obj[0] = args;
43890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43893 }
43894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43895 {
43896 PyThreadState* __tstate = wxPyBeginAllowThreads();
43897 result = ((wxMenuItem const *)arg1)->GetLabel();
43898 wxPyEndAllowThreads(__tstate);
43899 if (PyErr_Occurred()) SWIG_fail;
43900 }
43901 {
43902 #if wxUSE_UNICODE
43903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43904 #else
43905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43906 #endif
43907 }
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43915 PyObject *resultobj = 0;
43916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43917 wxString *result = 0 ;
43918 void *argp1 = 0 ;
43919 int res1 = 0 ;
43920 PyObject *swig_obj[1] ;
43921
43922 if (!args) SWIG_fail;
43923 swig_obj[0] = args;
43924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43925 if (!SWIG_IsOK(res1)) {
43926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43927 }
43928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 {
43932 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43933 result = (wxString *) &_result_ref;
43934 }
43935 wxPyEndAllowThreads(__tstate);
43936 if (PyErr_Occurred()) SWIG_fail;
43937 }
43938 {
43939 #if wxUSE_UNICODE
43940 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43941 #else
43942 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43943 #endif
43944 }
43945 return resultobj;
43946 fail:
43947 return NULL;
43948 }
43949
43950
43951 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43952 PyObject *resultobj = 0;
43953 wxString *arg1 = 0 ;
43954 wxString result;
43955 bool temp1 = false ;
43956 PyObject * obj0 = 0 ;
43957 char * kwnames[] = {
43958 (char *) "text", NULL
43959 };
43960
43961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43962 {
43963 arg1 = wxString_in_helper(obj0);
43964 if (arg1 == NULL) SWIG_fail;
43965 temp1 = true;
43966 }
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 #if wxUSE_UNICODE
43975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43976 #else
43977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43978 #endif
43979 }
43980 {
43981 if (temp1)
43982 delete arg1;
43983 }
43984 return resultobj;
43985 fail:
43986 {
43987 if (temp1)
43988 delete arg1;
43989 }
43990 return NULL;
43991 }
43992
43993
43994 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43995 PyObject *resultobj = 0;
43996 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43997 wxItemKind result;
43998 void *argp1 = 0 ;
43999 int res1 = 0 ;
44000 PyObject *swig_obj[1] ;
44001
44002 if (!args) SWIG_fail;
44003 swig_obj[0] = args;
44004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44005 if (!SWIG_IsOK(res1)) {
44006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44007 }
44008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_From_int(static_cast< int >(result));
44016 return resultobj;
44017 fail:
44018 return NULL;
44019 }
44020
44021
44022 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44023 PyObject *resultobj = 0;
44024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44025 wxItemKind arg2 ;
44026 void *argp1 = 0 ;
44027 int res1 = 0 ;
44028 int val2 ;
44029 int ecode2 = 0 ;
44030 PyObject * obj0 = 0 ;
44031 PyObject * obj1 = 0 ;
44032 char * kwnames[] = {
44033 (char *) "self",(char *) "kind", NULL
44034 };
44035
44036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44038 if (!SWIG_IsOK(res1)) {
44039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44040 }
44041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44042 ecode2 = SWIG_AsVal_int(obj1, &val2);
44043 if (!SWIG_IsOK(ecode2)) {
44044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44045 }
44046 arg2 = static_cast< wxItemKind >(val2);
44047 {
44048 PyThreadState* __tstate = wxPyBeginAllowThreads();
44049 (arg1)->SetKind(arg2);
44050 wxPyEndAllowThreads(__tstate);
44051 if (PyErr_Occurred()) SWIG_fail;
44052 }
44053 resultobj = SWIG_Py_Void();
44054 return resultobj;
44055 fail:
44056 return NULL;
44057 }
44058
44059
44060 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44061 PyObject *resultobj = 0;
44062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44063 bool arg2 ;
44064 void *argp1 = 0 ;
44065 int res1 = 0 ;
44066 bool val2 ;
44067 int ecode2 = 0 ;
44068 PyObject * obj0 = 0 ;
44069 PyObject * obj1 = 0 ;
44070 char * kwnames[] = {
44071 (char *) "self",(char *) "checkable", NULL
44072 };
44073
44074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44076 if (!SWIG_IsOK(res1)) {
44077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44078 }
44079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44081 if (!SWIG_IsOK(ecode2)) {
44082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44083 }
44084 arg2 = static_cast< bool >(val2);
44085 {
44086 PyThreadState* __tstate = wxPyBeginAllowThreads();
44087 (arg1)->SetCheckable(arg2);
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 resultobj = SWIG_Py_Void();
44092 return resultobj;
44093 fail:
44094 return NULL;
44095 }
44096
44097
44098 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44099 PyObject *resultobj = 0;
44100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44101 bool result;
44102 void *argp1 = 0 ;
44103 int res1 = 0 ;
44104 PyObject *swig_obj[1] ;
44105
44106 if (!args) SWIG_fail;
44107 swig_obj[0] = args;
44108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44109 if (!SWIG_IsOK(res1)) {
44110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44111 }
44112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44113 {
44114 PyThreadState* __tstate = wxPyBeginAllowThreads();
44115 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44116 wxPyEndAllowThreads(__tstate);
44117 if (PyErr_Occurred()) SWIG_fail;
44118 }
44119 {
44120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44121 }
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44129 PyObject *resultobj = 0;
44130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44131 bool result;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 PyObject *swig_obj[1] ;
44135
44136 if (!args) SWIG_fail;
44137 swig_obj[0] = args;
44138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44139 if (!SWIG_IsOK(res1)) {
44140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44141 }
44142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 {
44150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44151 }
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44159 PyObject *resultobj = 0;
44160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44161 wxMenu *arg2 = (wxMenu *) 0 ;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 void *argp2 = 0 ;
44165 int res2 = 0 ;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 char * kwnames[] = {
44169 (char *) "self",(char *) "menu", NULL
44170 };
44171
44172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44174 if (!SWIG_IsOK(res1)) {
44175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44176 }
44177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44179 if (!SWIG_IsOK(res2)) {
44180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44181 }
44182 arg2 = reinterpret_cast< wxMenu * >(argp2);
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 (arg1)->SetSubMenu(arg2);
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_Py_Void();
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44197 PyObject *resultobj = 0;
44198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44199 wxMenu *result = 0 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 PyObject *swig_obj[1] ;
44203
44204 if (!args) SWIG_fail;
44205 swig_obj[0] = args;
44206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44207 if (!SWIG_IsOK(res1)) {
44208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44209 }
44210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44211 {
44212 PyThreadState* __tstate = wxPyBeginAllowThreads();
44213 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44214 wxPyEndAllowThreads(__tstate);
44215 if (PyErr_Occurred()) SWIG_fail;
44216 }
44217 {
44218 resultobj = wxPyMake_wxObject(result, 0);
44219 }
44220 return resultobj;
44221 fail:
44222 return NULL;
44223 }
44224
44225
44226 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44227 PyObject *resultobj = 0;
44228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44229 bool arg2 = (bool) true ;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 bool val2 ;
44233 int ecode2 = 0 ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 char * kwnames[] = {
44237 (char *) "self",(char *) "enable", NULL
44238 };
44239
44240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44244 }
44245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44246 if (obj1) {
44247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44248 if (!SWIG_IsOK(ecode2)) {
44249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44250 }
44251 arg2 = static_cast< bool >(val2);
44252 }
44253 {
44254 PyThreadState* __tstate = wxPyBeginAllowThreads();
44255 (arg1)->Enable(arg2);
44256 wxPyEndAllowThreads(__tstate);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 }
44259 resultobj = SWIG_Py_Void();
44260 return resultobj;
44261 fail:
44262 return NULL;
44263 }
44264
44265
44266 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44267 PyObject *resultobj = 0;
44268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44269 bool result;
44270 void *argp1 = 0 ;
44271 int res1 = 0 ;
44272 PyObject *swig_obj[1] ;
44273
44274 if (!args) SWIG_fail;
44275 swig_obj[0] = args;
44276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44277 if (!SWIG_IsOK(res1)) {
44278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44279 }
44280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44284 wxPyEndAllowThreads(__tstate);
44285 if (PyErr_Occurred()) SWIG_fail;
44286 }
44287 {
44288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44289 }
44290 return resultobj;
44291 fail:
44292 return NULL;
44293 }
44294
44295
44296 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44297 PyObject *resultobj = 0;
44298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44299 bool arg2 = (bool) true ;
44300 void *argp1 = 0 ;
44301 int res1 = 0 ;
44302 bool val2 ;
44303 int ecode2 = 0 ;
44304 PyObject * obj0 = 0 ;
44305 PyObject * obj1 = 0 ;
44306 char * kwnames[] = {
44307 (char *) "self",(char *) "check", NULL
44308 };
44309
44310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44312 if (!SWIG_IsOK(res1)) {
44313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44314 }
44315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44316 if (obj1) {
44317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44318 if (!SWIG_IsOK(ecode2)) {
44319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44320 }
44321 arg2 = static_cast< bool >(val2);
44322 }
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 (arg1)->Check(arg2);
44326 wxPyEndAllowThreads(__tstate);
44327 if (PyErr_Occurred()) SWIG_fail;
44328 }
44329 resultobj = SWIG_Py_Void();
44330 return resultobj;
44331 fail:
44332 return NULL;
44333 }
44334
44335
44336 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44337 PyObject *resultobj = 0;
44338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44339 bool result;
44340 void *argp1 = 0 ;
44341 int res1 = 0 ;
44342 PyObject *swig_obj[1] ;
44343
44344 if (!args) SWIG_fail;
44345 swig_obj[0] = args;
44346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44349 }
44350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44354 wxPyEndAllowThreads(__tstate);
44355 if (PyErr_Occurred()) SWIG_fail;
44356 }
44357 {
44358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44359 }
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44367 PyObject *resultobj = 0;
44368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 (arg1)->Toggle();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 resultobj = SWIG_Py_Void();
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44396 wxString *arg2 = 0 ;
44397 void *argp1 = 0 ;
44398 int res1 = 0 ;
44399 bool temp2 = false ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 char * kwnames[] = {
44403 (char *) "self",(char *) "str", NULL
44404 };
44405
44406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44410 }
44411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44412 {
44413 arg2 = wxString_in_helper(obj1);
44414 if (arg2 == NULL) SWIG_fail;
44415 temp2 = true;
44416 }
44417 {
44418 PyThreadState* __tstate = wxPyBeginAllowThreads();
44419 (arg1)->SetHelp((wxString const &)*arg2);
44420 wxPyEndAllowThreads(__tstate);
44421 if (PyErr_Occurred()) SWIG_fail;
44422 }
44423 resultobj = SWIG_Py_Void();
44424 {
44425 if (temp2)
44426 delete arg2;
44427 }
44428 return resultobj;
44429 fail:
44430 {
44431 if (temp2)
44432 delete arg2;
44433 }
44434 return NULL;
44435 }
44436
44437
44438 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44439 PyObject *resultobj = 0;
44440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44441 wxString *result = 0 ;
44442 void *argp1 = 0 ;
44443 int res1 = 0 ;
44444 PyObject *swig_obj[1] ;
44445
44446 if (!args) SWIG_fail;
44447 swig_obj[0] = args;
44448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44449 if (!SWIG_IsOK(res1)) {
44450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44451 }
44452 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44453 {
44454 PyThreadState* __tstate = wxPyBeginAllowThreads();
44455 {
44456 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44457 result = (wxString *) &_result_ref;
44458 }
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 {
44463 #if wxUSE_UNICODE
44464 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44465 #else
44466 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44467 #endif
44468 }
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44476 PyObject *resultobj = 0;
44477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44478 wxAcceleratorEntry *result = 0 ;
44479 void *argp1 = 0 ;
44480 int res1 = 0 ;
44481 PyObject *swig_obj[1] ;
44482
44483 if (!args) SWIG_fail;
44484 swig_obj[0] = args;
44485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44486 if (!SWIG_IsOK(res1)) {
44487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44488 }
44489 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44490 {
44491 PyThreadState* __tstate = wxPyBeginAllowThreads();
44492 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44493 wxPyEndAllowThreads(__tstate);
44494 if (PyErr_Occurred()) SWIG_fail;
44495 }
44496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44497 return resultobj;
44498 fail:
44499 return NULL;
44500 }
44501
44502
44503 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj = 0;
44505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44506 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44507 void *argp1 = 0 ;
44508 int res1 = 0 ;
44509 void *argp2 = 0 ;
44510 int res2 = 0 ;
44511 PyObject * obj0 = 0 ;
44512 PyObject * obj1 = 0 ;
44513 char * kwnames[] = {
44514 (char *) "self",(char *) "accel", NULL
44515 };
44516
44517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44519 if (!SWIG_IsOK(res1)) {
44520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44521 }
44522 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44524 if (!SWIG_IsOK(res2)) {
44525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44526 }
44527 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 (arg1)->SetAccel(arg2);
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 resultobj = SWIG_Py_Void();
44535 return resultobj;
44536 fail:
44537 return NULL;
44538 }
44539
44540
44541 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44542 PyObject *resultobj = 0;
44543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44544 wxBitmap *arg2 = 0 ;
44545 void *argp1 = 0 ;
44546 int res1 = 0 ;
44547 void *argp2 = 0 ;
44548 int res2 = 0 ;
44549 PyObject * obj0 = 0 ;
44550 PyObject * obj1 = 0 ;
44551 char * kwnames[] = {
44552 (char *) "self",(char *) "bitmap", NULL
44553 };
44554
44555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44557 if (!SWIG_IsOK(res1)) {
44558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44559 }
44560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44562 if (!SWIG_IsOK(res2)) {
44563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44564 }
44565 if (!argp2) {
44566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44567 }
44568 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44569 {
44570 PyThreadState* __tstate = wxPyBeginAllowThreads();
44571 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44572 wxPyEndAllowThreads(__tstate);
44573 if (PyErr_Occurred()) SWIG_fail;
44574 }
44575 resultobj = SWIG_Py_Void();
44576 return resultobj;
44577 fail:
44578 return NULL;
44579 }
44580
44581
44582 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44583 PyObject *resultobj = 0;
44584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44585 wxBitmap *result = 0 ;
44586 void *argp1 = 0 ;
44587 int res1 = 0 ;
44588 PyObject *swig_obj[1] ;
44589
44590 if (!args) SWIG_fail;
44591 swig_obj[0] = args;
44592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44593 if (!SWIG_IsOK(res1)) {
44594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44595 }
44596 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44597 {
44598 PyThreadState* __tstate = wxPyBeginAllowThreads();
44599 {
44600 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44601 result = (wxBitmap *) &_result_ref;
44602 }
44603 wxPyEndAllowThreads(__tstate);
44604 if (PyErr_Occurred()) SWIG_fail;
44605 }
44606 {
44607 wxBitmap* resultptr = new wxBitmap(*result);
44608 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44609 }
44610 return resultobj;
44611 fail:
44612 return NULL;
44613 }
44614
44615
44616 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44617 PyObject *resultobj = 0;
44618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44619 wxFont *arg2 = 0 ;
44620 void *argp1 = 0 ;
44621 int res1 = 0 ;
44622 void *argp2 = 0 ;
44623 int res2 = 0 ;
44624 PyObject * obj0 = 0 ;
44625 PyObject * obj1 = 0 ;
44626 char * kwnames[] = {
44627 (char *) "self",(char *) "font", NULL
44628 };
44629
44630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44632 if (!SWIG_IsOK(res1)) {
44633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44634 }
44635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44637 if (!SWIG_IsOK(res2)) {
44638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44639 }
44640 if (!argp2) {
44641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44642 }
44643 arg2 = reinterpret_cast< wxFont * >(argp2);
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 (arg1)->SetFont((wxFont const &)*arg2);
44647 wxPyEndAllowThreads(__tstate);
44648 if (PyErr_Occurred()) SWIG_fail;
44649 }
44650 resultobj = SWIG_Py_Void();
44651 return resultobj;
44652 fail:
44653 return NULL;
44654 }
44655
44656
44657 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44658 PyObject *resultobj = 0;
44659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44660 wxFont result;
44661 void *argp1 = 0 ;
44662 int res1 = 0 ;
44663 PyObject *swig_obj[1] ;
44664
44665 if (!args) SWIG_fail;
44666 swig_obj[0] = args;
44667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44668 if (!SWIG_IsOK(res1)) {
44669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44670 }
44671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44672 {
44673 PyThreadState* __tstate = wxPyBeginAllowThreads();
44674 result = (arg1)->GetFont();
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44679 return resultobj;
44680 fail:
44681 return NULL;
44682 }
44683
44684
44685 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44686 PyObject *resultobj = 0;
44687 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44688 wxColour *arg2 = 0 ;
44689 void *argp1 = 0 ;
44690 int res1 = 0 ;
44691 wxColour temp2 ;
44692 PyObject * obj0 = 0 ;
44693 PyObject * obj1 = 0 ;
44694 char * kwnames[] = {
44695 (char *) "self",(char *) "colText", NULL
44696 };
44697
44698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44702 }
44703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44704 {
44705 arg2 = &temp2;
44706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44707 }
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 (arg1)->SetTextColour((wxColour const &)*arg2);
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 resultobj = SWIG_Py_Void();
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44722 PyObject *resultobj = 0;
44723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44724 wxColour result;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 PyObject *swig_obj[1] ;
44728
44729 if (!args) SWIG_fail;
44730 swig_obj[0] = args;
44731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44732 if (!SWIG_IsOK(res1)) {
44733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44734 }
44735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44736 {
44737 PyThreadState* __tstate = wxPyBeginAllowThreads();
44738 result = (arg1)->GetTextColour();
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44750 PyObject *resultobj = 0;
44751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44752 wxColour *arg2 = 0 ;
44753 void *argp1 = 0 ;
44754 int res1 = 0 ;
44755 wxColour temp2 ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 char * kwnames[] = {
44759 (char *) "self",(char *) "colBack", NULL
44760 };
44761
44762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44764 if (!SWIG_IsOK(res1)) {
44765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44766 }
44767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44768 {
44769 arg2 = &temp2;
44770 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44771 }
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 resultobj = SWIG_Py_Void();
44779 return resultobj;
44780 fail:
44781 return NULL;
44782 }
44783
44784
44785 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44786 PyObject *resultobj = 0;
44787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44788 wxColour result;
44789 void *argp1 = 0 ;
44790 int res1 = 0 ;
44791 PyObject *swig_obj[1] ;
44792
44793 if (!args) SWIG_fail;
44794 swig_obj[0] = args;
44795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44798 }
44799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44800 {
44801 PyThreadState* __tstate = wxPyBeginAllowThreads();
44802 result = (arg1)->GetBackgroundColour();
44803 wxPyEndAllowThreads(__tstate);
44804 if (PyErr_Occurred()) SWIG_fail;
44805 }
44806 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44807 return resultobj;
44808 fail:
44809 return NULL;
44810 }
44811
44812
44813 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44814 PyObject *resultobj = 0;
44815 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44816 wxBitmap *arg2 = 0 ;
44817 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44818 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44819 void *argp1 = 0 ;
44820 int res1 = 0 ;
44821 void *argp2 = 0 ;
44822 int res2 = 0 ;
44823 void *argp3 = 0 ;
44824 int res3 = 0 ;
44825 PyObject * obj0 = 0 ;
44826 PyObject * obj1 = 0 ;
44827 PyObject * obj2 = 0 ;
44828 char * kwnames[] = {
44829 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44830 };
44831
44832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44834 if (!SWIG_IsOK(res1)) {
44835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44836 }
44837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44839 if (!SWIG_IsOK(res2)) {
44840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44841 }
44842 if (!argp2) {
44843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44844 }
44845 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44846 if (obj2) {
44847 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44848 if (!SWIG_IsOK(res3)) {
44849 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44850 }
44851 if (!argp3) {
44852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44853 }
44854 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44855 }
44856 {
44857 PyThreadState* __tstate = wxPyBeginAllowThreads();
44858 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44859 wxPyEndAllowThreads(__tstate);
44860 if (PyErr_Occurred()) SWIG_fail;
44861 }
44862 resultobj = SWIG_Py_Void();
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44870 PyObject *resultobj = 0;
44871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44872 wxBitmap *arg2 = 0 ;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 void *argp2 = 0 ;
44876 int res2 = 0 ;
44877 PyObject * obj0 = 0 ;
44878 PyObject * obj1 = 0 ;
44879 char * kwnames[] = {
44880 (char *) "self",(char *) "bmpDisabled", NULL
44881 };
44882
44883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44885 if (!SWIG_IsOK(res1)) {
44886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44887 }
44888 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44890 if (!SWIG_IsOK(res2)) {
44891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44892 }
44893 if (!argp2) {
44894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44895 }
44896 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_Py_Void();
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *resultobj = 0;
44912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44913 wxBitmap *result = 0 ;
44914 void *argp1 = 0 ;
44915 int res1 = 0 ;
44916 PyObject *swig_obj[1] ;
44917
44918 if (!args) SWIG_fail;
44919 swig_obj[0] = args;
44920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44921 if (!SWIG_IsOK(res1)) {
44922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44923 }
44924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 {
44928 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44929 result = (wxBitmap *) &_result_ref;
44930 }
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 wxBitmap* resultptr = new wxBitmap(*result);
44936 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44937 }
44938 return resultobj;
44939 fail:
44940 return NULL;
44941 }
44942
44943
44944 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44945 PyObject *resultobj = 0;
44946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44947 int arg2 ;
44948 void *argp1 = 0 ;
44949 int res1 = 0 ;
44950 int val2 ;
44951 int ecode2 = 0 ;
44952 PyObject * obj0 = 0 ;
44953 PyObject * obj1 = 0 ;
44954 char * kwnames[] = {
44955 (char *) "self",(char *) "nWidth", NULL
44956 };
44957
44958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44960 if (!SWIG_IsOK(res1)) {
44961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44962 }
44963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44964 ecode2 = SWIG_AsVal_int(obj1, &val2);
44965 if (!SWIG_IsOK(ecode2)) {
44966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44967 }
44968 arg2 = static_cast< int >(val2);
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 (arg1)->SetMarginWidth(arg2);
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 resultobj = SWIG_Py_Void();
44976 return resultobj;
44977 fail:
44978 return NULL;
44979 }
44980
44981
44982 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44983 PyObject *resultobj = 0;
44984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44985 int result;
44986 void *argp1 = 0 ;
44987 int res1 = 0 ;
44988 PyObject *swig_obj[1] ;
44989
44990 if (!args) SWIG_fail;
44991 swig_obj[0] = args;
44992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44995 }
44996 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44997 {
44998 PyThreadState* __tstate = wxPyBeginAllowThreads();
44999 result = (int)(arg1)->GetMarginWidth();
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 resultobj = SWIG_From_int(static_cast< int >(result));
45004 return resultobj;
45005 fail:
45006 return NULL;
45007 }
45008
45009
45010 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45011 PyObject *resultobj = 0;
45012 int result;
45013
45014 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 result = (int)wxMenuItem::GetDefaultMarginWidth();
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 resultobj = SWIG_From_int(static_cast< int >(result));
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45029 PyObject *resultobj = 0;
45030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45031 bool result;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 PyObject *swig_obj[1] ;
45035
45036 if (!args) SWIG_fail;
45037 swig_obj[0] = args;
45038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45039 if (!SWIG_IsOK(res1)) {
45040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45041 }
45042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45043 {
45044 PyThreadState* __tstate = wxPyBeginAllowThreads();
45045 result = (bool)(arg1)->IsOwnerDrawn();
45046 wxPyEndAllowThreads(__tstate);
45047 if (PyErr_Occurred()) SWIG_fail;
45048 }
45049 {
45050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45051 }
45052 return resultobj;
45053 fail:
45054 return NULL;
45055 }
45056
45057
45058 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45059 PyObject *resultobj = 0;
45060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45061 bool arg2 = (bool) true ;
45062 void *argp1 = 0 ;
45063 int res1 = 0 ;
45064 bool val2 ;
45065 int ecode2 = 0 ;
45066 PyObject * obj0 = 0 ;
45067 PyObject * obj1 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "ownerDrawn", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45076 }
45077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45078 if (obj1) {
45079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45080 if (!SWIG_IsOK(ecode2)) {
45081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45082 }
45083 arg2 = static_cast< bool >(val2);
45084 }
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 (arg1)->SetOwnerDrawn(arg2);
45088 wxPyEndAllowThreads(__tstate);
45089 if (PyErr_Occurred()) SWIG_fail;
45090 }
45091 resultobj = SWIG_Py_Void();
45092 return resultobj;
45093 fail:
45094 return NULL;
45095 }
45096
45097
45098 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45099 PyObject *resultobj = 0;
45100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45101 void *argp1 = 0 ;
45102 int res1 = 0 ;
45103 PyObject *swig_obj[1] ;
45104
45105 if (!args) SWIG_fail;
45106 swig_obj[0] = args;
45107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45108 if (!SWIG_IsOK(res1)) {
45109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45110 }
45111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45112 {
45113 PyThreadState* __tstate = wxPyBeginAllowThreads();
45114 (arg1)->ResetOwnerDrawn();
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 resultobj = SWIG_Py_Void();
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45126 PyObject *obj;
45127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45128 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45129 return SWIG_Py_Void();
45130 }
45131
45132 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45133 return SWIG_Python_InitShadowInstance(args);
45134 }
45135
45136 SWIGINTERN int ControlNameStr_set(PyObject *) {
45137 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45138 return 1;
45139 }
45140
45141
45142 SWIGINTERN PyObject *ControlNameStr_get(void) {
45143 PyObject *pyobj = 0;
45144
45145 {
45146 #if wxUSE_UNICODE
45147 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45148 #else
45149 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45150 #endif
45151 }
45152 return pyobj;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxWindow *arg1 = (wxWindow *) 0 ;
45159 int arg2 = (int) -1 ;
45160 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45161 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45162 wxSize const &arg4_defvalue = wxDefaultSize ;
45163 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45164 long arg5 = (long) 0 ;
45165 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45166 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45167 wxString const &arg7_defvalue = wxPyControlNameStr ;
45168 wxString *arg7 = (wxString *) &arg7_defvalue ;
45169 wxControl *result = 0 ;
45170 void *argp1 = 0 ;
45171 int res1 = 0 ;
45172 int val2 ;
45173 int ecode2 = 0 ;
45174 wxPoint temp3 ;
45175 wxSize temp4 ;
45176 long val5 ;
45177 int ecode5 = 0 ;
45178 void *argp6 = 0 ;
45179 int res6 = 0 ;
45180 bool temp7 = false ;
45181 PyObject * obj0 = 0 ;
45182 PyObject * obj1 = 0 ;
45183 PyObject * obj2 = 0 ;
45184 PyObject * obj3 = 0 ;
45185 PyObject * obj4 = 0 ;
45186 PyObject * obj5 = 0 ;
45187 PyObject * obj6 = 0 ;
45188 char * kwnames[] = {
45189 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45190 };
45191
45192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45194 if (!SWIG_IsOK(res1)) {
45195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45196 }
45197 arg1 = reinterpret_cast< wxWindow * >(argp1);
45198 if (obj1) {
45199 ecode2 = SWIG_AsVal_int(obj1, &val2);
45200 if (!SWIG_IsOK(ecode2)) {
45201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45202 }
45203 arg2 = static_cast< int >(val2);
45204 }
45205 if (obj2) {
45206 {
45207 arg3 = &temp3;
45208 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45209 }
45210 }
45211 if (obj3) {
45212 {
45213 arg4 = &temp4;
45214 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45215 }
45216 }
45217 if (obj4) {
45218 ecode5 = SWIG_AsVal_long(obj4, &val5);
45219 if (!SWIG_IsOK(ecode5)) {
45220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45221 }
45222 arg5 = static_cast< long >(val5);
45223 }
45224 if (obj5) {
45225 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45226 if (!SWIG_IsOK(res6)) {
45227 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45228 }
45229 if (!argp6) {
45230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45231 }
45232 arg6 = reinterpret_cast< wxValidator * >(argp6);
45233 }
45234 if (obj6) {
45235 {
45236 arg7 = wxString_in_helper(obj6);
45237 if (arg7 == NULL) SWIG_fail;
45238 temp7 = true;
45239 }
45240 }
45241 {
45242 if (!wxPyCheckForApp()) SWIG_fail;
45243 PyThreadState* __tstate = wxPyBeginAllowThreads();
45244 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45249 {
45250 if (temp7)
45251 delete arg7;
45252 }
45253 return resultobj;
45254 fail:
45255 {
45256 if (temp7)
45257 delete arg7;
45258 }
45259 return NULL;
45260 }
45261
45262
45263 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45264 PyObject *resultobj = 0;
45265 wxControl *result = 0 ;
45266
45267 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45268 {
45269 if (!wxPyCheckForApp()) SWIG_fail;
45270 PyThreadState* __tstate = wxPyBeginAllowThreads();
45271 result = (wxControl *)new wxControl();
45272 wxPyEndAllowThreads(__tstate);
45273 if (PyErr_Occurred()) SWIG_fail;
45274 }
45275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45276 return resultobj;
45277 fail:
45278 return NULL;
45279 }
45280
45281
45282 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45283 PyObject *resultobj = 0;
45284 wxControl *arg1 = (wxControl *) 0 ;
45285 wxWindow *arg2 = (wxWindow *) 0 ;
45286 int arg3 = (int) -1 ;
45287 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45288 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45289 wxSize const &arg5_defvalue = wxDefaultSize ;
45290 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45291 long arg6 = (long) 0 ;
45292 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45293 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45294 wxString const &arg8_defvalue = wxPyControlNameStr ;
45295 wxString *arg8 = (wxString *) &arg8_defvalue ;
45296 bool result;
45297 void *argp1 = 0 ;
45298 int res1 = 0 ;
45299 void *argp2 = 0 ;
45300 int res2 = 0 ;
45301 int val3 ;
45302 int ecode3 = 0 ;
45303 wxPoint temp4 ;
45304 wxSize temp5 ;
45305 long val6 ;
45306 int ecode6 = 0 ;
45307 void *argp7 = 0 ;
45308 int res7 = 0 ;
45309 bool temp8 = false ;
45310 PyObject * obj0 = 0 ;
45311 PyObject * obj1 = 0 ;
45312 PyObject * obj2 = 0 ;
45313 PyObject * obj3 = 0 ;
45314 PyObject * obj4 = 0 ;
45315 PyObject * obj5 = 0 ;
45316 PyObject * obj6 = 0 ;
45317 PyObject * obj7 = 0 ;
45318 char * kwnames[] = {
45319 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45320 };
45321
45322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45326 }
45327 arg1 = reinterpret_cast< wxControl * >(argp1);
45328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45329 if (!SWIG_IsOK(res2)) {
45330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45331 }
45332 arg2 = reinterpret_cast< wxWindow * >(argp2);
45333 if (obj2) {
45334 ecode3 = SWIG_AsVal_int(obj2, &val3);
45335 if (!SWIG_IsOK(ecode3)) {
45336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45337 }
45338 arg3 = static_cast< int >(val3);
45339 }
45340 if (obj3) {
45341 {
45342 arg4 = &temp4;
45343 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45344 }
45345 }
45346 if (obj4) {
45347 {
45348 arg5 = &temp5;
45349 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45350 }
45351 }
45352 if (obj5) {
45353 ecode6 = SWIG_AsVal_long(obj5, &val6);
45354 if (!SWIG_IsOK(ecode6)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45356 }
45357 arg6 = static_cast< long >(val6);
45358 }
45359 if (obj6) {
45360 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45361 if (!SWIG_IsOK(res7)) {
45362 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45363 }
45364 if (!argp7) {
45365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45366 }
45367 arg7 = reinterpret_cast< wxValidator * >(argp7);
45368 }
45369 if (obj7) {
45370 {
45371 arg8 = wxString_in_helper(obj7);
45372 if (arg8 == NULL) SWIG_fail;
45373 temp8 = true;
45374 }
45375 }
45376 {
45377 PyThreadState* __tstate = wxPyBeginAllowThreads();
45378 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45379 wxPyEndAllowThreads(__tstate);
45380 if (PyErr_Occurred()) SWIG_fail;
45381 }
45382 {
45383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45384 }
45385 {
45386 if (temp8)
45387 delete arg8;
45388 }
45389 return resultobj;
45390 fail:
45391 {
45392 if (temp8)
45393 delete arg8;
45394 }
45395 return NULL;
45396 }
45397
45398
45399 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45400 PyObject *resultobj = 0;
45401 wxControl *arg1 = (wxControl *) 0 ;
45402 int result;
45403 void *argp1 = 0 ;
45404 int res1 = 0 ;
45405 PyObject *swig_obj[1] ;
45406
45407 if (!args) SWIG_fail;
45408 swig_obj[0] = args;
45409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45410 if (!SWIG_IsOK(res1)) {
45411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45412 }
45413 arg1 = reinterpret_cast< wxControl * >(argp1);
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 result = (int)((wxControl const *)arg1)->GetAlignment();
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 resultobj = SWIG_From_int(static_cast< int >(result));
45421 return resultobj;
45422 fail:
45423 return NULL;
45424 }
45425
45426
45427 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45428 PyObject *resultobj = 0;
45429 wxControl *arg1 = (wxControl *) 0 ;
45430 wxString result;
45431 void *argp1 = 0 ;
45432 int res1 = 0 ;
45433 PyObject *swig_obj[1] ;
45434
45435 if (!args) SWIG_fail;
45436 swig_obj[0] = args;
45437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45438 if (!SWIG_IsOK(res1)) {
45439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45440 }
45441 arg1 = reinterpret_cast< wxControl * >(argp1);
45442 {
45443 PyThreadState* __tstate = wxPyBeginAllowThreads();
45444 result = ((wxControl const *)arg1)->GetLabelText();
45445 wxPyEndAllowThreads(__tstate);
45446 if (PyErr_Occurred()) SWIG_fail;
45447 }
45448 {
45449 #if wxUSE_UNICODE
45450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45451 #else
45452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45453 #endif
45454 }
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj = 0;
45463 wxControl *arg1 = (wxControl *) 0 ;
45464 wxCommandEvent *arg2 = 0 ;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 void *argp2 = 0 ;
45468 int res2 = 0 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "event", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45479 }
45480 arg1 = reinterpret_cast< wxControl * >(argp1);
45481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45482 if (!SWIG_IsOK(res2)) {
45483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45484 }
45485 if (!argp2) {
45486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45487 }
45488 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 (arg1)->Command(*arg2);
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 resultobj = SWIG_Py_Void();
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45503 PyObject *resultobj = 0;
45504 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45505 SwigValueWrapper<wxVisualAttributes > result;
45506 int val1 ;
45507 int ecode1 = 0 ;
45508 PyObject * obj0 = 0 ;
45509 char * kwnames[] = {
45510 (char *) "variant", NULL
45511 };
45512
45513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45514 if (obj0) {
45515 ecode1 = SWIG_AsVal_int(obj0, &val1);
45516 if (!SWIG_IsOK(ecode1)) {
45517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45518 }
45519 arg1 = static_cast< wxWindowVariant >(val1);
45520 }
45521 {
45522 if (!wxPyCheckForApp()) SWIG_fail;
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 result = wxControl::GetClassDefaultAttributes(arg1);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45529 return resultobj;
45530 fail:
45531 return NULL;
45532 }
45533
45534
45535 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45536 PyObject *obj;
45537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45538 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45539 return SWIG_Py_Void();
45540 }
45541
45542 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45543 return SWIG_Python_InitShadowInstance(args);
45544 }
45545
45546 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45547 PyObject *resultobj = 0;
45548 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45549 wxString *arg2 = 0 ;
45550 PyObject *arg3 = (PyObject *) NULL ;
45551 int result;
45552 void *argp1 = 0 ;
45553 int res1 = 0 ;
45554 bool temp2 = false ;
45555 PyObject * obj0 = 0 ;
45556 PyObject * obj1 = 0 ;
45557 PyObject * obj2 = 0 ;
45558 char * kwnames[] = {
45559 (char *) "self",(char *) "item",(char *) "clientData", NULL
45560 };
45561
45562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45566 }
45567 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45568 {
45569 arg2 = wxString_in_helper(obj1);
45570 if (arg2 == NULL) SWIG_fail;
45571 temp2 = true;
45572 }
45573 if (obj2) {
45574 arg3 = obj2;
45575 }
45576 {
45577 PyThreadState* __tstate = wxPyBeginAllowThreads();
45578 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45579 wxPyEndAllowThreads(__tstate);
45580 if (PyErr_Occurred()) SWIG_fail;
45581 }
45582 resultobj = SWIG_From_int(static_cast< int >(result));
45583 {
45584 if (temp2)
45585 delete arg2;
45586 }
45587 return resultobj;
45588 fail:
45589 {
45590 if (temp2)
45591 delete arg2;
45592 }
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45598 PyObject *resultobj = 0;
45599 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45600 wxArrayString *arg2 = 0 ;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 bool temp2 = false ;
45604 PyObject * obj0 = 0 ;
45605 PyObject * obj1 = 0 ;
45606 char * kwnames[] = {
45607 (char *) "self",(char *) "strings", NULL
45608 };
45609
45610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45612 if (!SWIG_IsOK(res1)) {
45613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45614 }
45615 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45616 {
45617 if (! PySequence_Check(obj1)) {
45618 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45619 SWIG_fail;
45620 }
45621 arg2 = new wxArrayString;
45622 temp2 = true;
45623 int i, len=PySequence_Length(obj1);
45624 for (i=0; i<len; i++) {
45625 PyObject* item = PySequence_GetItem(obj1, i);
45626 wxString* s = wxString_in_helper(item);
45627 if (PyErr_Occurred()) SWIG_fail;
45628 arg2->Add(*s);
45629 delete s;
45630 Py_DECREF(item);
45631 }
45632 }
45633 {
45634 PyThreadState* __tstate = wxPyBeginAllowThreads();
45635 (arg1)->Append((wxArrayString const &)*arg2);
45636 wxPyEndAllowThreads(__tstate);
45637 if (PyErr_Occurred()) SWIG_fail;
45638 }
45639 resultobj = SWIG_Py_Void();
45640 {
45641 if (temp2) delete arg2;
45642 }
45643 return resultobj;
45644 fail:
45645 {
45646 if (temp2) delete arg2;
45647 }
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45653 PyObject *resultobj = 0;
45654 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45655 wxString *arg2 = 0 ;
45656 unsigned int arg3 ;
45657 PyObject *arg4 = (PyObject *) NULL ;
45658 int result;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 bool temp2 = false ;
45662 unsigned int val3 ;
45663 int ecode3 = 0 ;
45664 PyObject * obj0 = 0 ;
45665 PyObject * obj1 = 0 ;
45666 PyObject * obj2 = 0 ;
45667 PyObject * obj3 = 0 ;
45668 char * kwnames[] = {
45669 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45670 };
45671
45672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45676 }
45677 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45678 {
45679 arg2 = wxString_in_helper(obj1);
45680 if (arg2 == NULL) SWIG_fail;
45681 temp2 = true;
45682 }
45683 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45684 if (!SWIG_IsOK(ecode3)) {
45685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45686 }
45687 arg3 = static_cast< unsigned int >(val3);
45688 if (obj3) {
45689 arg4 = obj3;
45690 }
45691 {
45692 PyThreadState* __tstate = wxPyBeginAllowThreads();
45693 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45694 wxPyEndAllowThreads(__tstate);
45695 if (PyErr_Occurred()) SWIG_fail;
45696 }
45697 resultobj = SWIG_From_int(static_cast< int >(result));
45698 {
45699 if (temp2)
45700 delete arg2;
45701 }
45702 return resultobj;
45703 fail:
45704 {
45705 if (temp2)
45706 delete arg2;
45707 }
45708 return NULL;
45709 }
45710
45711
45712 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45713 PyObject *resultobj = 0;
45714 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45715 void *argp1 = 0 ;
45716 int res1 = 0 ;
45717 PyObject *swig_obj[1] ;
45718
45719 if (!args) SWIG_fail;
45720 swig_obj[0] = args;
45721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45722 if (!SWIG_IsOK(res1)) {
45723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45724 }
45725 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 (arg1)->Clear();
45729 wxPyEndAllowThreads(__tstate);
45730 if (PyErr_Occurred()) SWIG_fail;
45731 }
45732 resultobj = SWIG_Py_Void();
45733 return resultobj;
45734 fail:
45735 return NULL;
45736 }
45737
45738
45739 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45740 PyObject *resultobj = 0;
45741 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45742 unsigned int arg2 ;
45743 void *argp1 = 0 ;
45744 int res1 = 0 ;
45745 unsigned int val2 ;
45746 int ecode2 = 0 ;
45747 PyObject * obj0 = 0 ;
45748 PyObject * obj1 = 0 ;
45749 char * kwnames[] = {
45750 (char *) "self",(char *) "n", NULL
45751 };
45752
45753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45755 if (!SWIG_IsOK(res1)) {
45756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45757 }
45758 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45759 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45760 if (!SWIG_IsOK(ecode2)) {
45761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45762 }
45763 arg2 = static_cast< unsigned int >(val2);
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 (arg1)->Delete(arg2);
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 resultobj = SWIG_Py_Void();
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45778 PyObject *resultobj = 0;
45779 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45780 unsigned int arg2 ;
45781 PyObject *result = 0 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 unsigned int val2 ;
45785 int ecode2 = 0 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "n", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45796 }
45797 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45798 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45799 if (!SWIG_IsOK(ecode2)) {
45800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45801 }
45802 arg2 = static_cast< unsigned int >(val2);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = result;
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj = 0;
45818 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45819 unsigned int arg2 ;
45820 PyObject *arg3 = (PyObject *) 0 ;
45821 void *argp1 = 0 ;
45822 int res1 = 0 ;
45823 unsigned int val2 ;
45824 int ecode2 = 0 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 PyObject * obj2 = 0 ;
45828 char * kwnames[] = {
45829 (char *) "self",(char *) "n",(char *) "clientData", NULL
45830 };
45831
45832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45834 if (!SWIG_IsOK(res1)) {
45835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45836 }
45837 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45838 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45839 if (!SWIG_IsOK(ecode2)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45841 }
45842 arg2 = static_cast< unsigned int >(val2);
45843 arg3 = obj2;
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 wxItemContainer_SetClientData(arg1,arg2,arg3);
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_Py_Void();
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45858 PyObject *resultobj = 0;
45859 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45860 unsigned int result;
45861 void *argp1 = 0 ;
45862 int res1 = 0 ;
45863 PyObject *swig_obj[1] ;
45864
45865 if (!args) SWIG_fail;
45866 swig_obj[0] = args;
45867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45868 if (!SWIG_IsOK(res1)) {
45869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45870 }
45871 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45872 {
45873 PyThreadState* __tstate = wxPyBeginAllowThreads();
45874 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45875 wxPyEndAllowThreads(__tstate);
45876 if (PyErr_Occurred()) SWIG_fail;
45877 }
45878 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45879 return resultobj;
45880 fail:
45881 return NULL;
45882 }
45883
45884
45885 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45886 PyObject *resultobj = 0;
45887 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45888 bool result;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 PyObject *swig_obj[1] ;
45892
45893 if (!args) SWIG_fail;
45894 swig_obj[0] = args;
45895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45896 if (!SWIG_IsOK(res1)) {
45897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45898 }
45899 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 {
45907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45908 }
45909 return resultobj;
45910 fail:
45911 return NULL;
45912 }
45913
45914
45915 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45916 PyObject *resultobj = 0;
45917 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45918 unsigned int arg2 ;
45919 wxString result;
45920 void *argp1 = 0 ;
45921 int res1 = 0 ;
45922 unsigned int val2 ;
45923 int ecode2 = 0 ;
45924 PyObject * obj0 = 0 ;
45925 PyObject * obj1 = 0 ;
45926 char * kwnames[] = {
45927 (char *) "self",(char *) "n", NULL
45928 };
45929
45930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45932 if (!SWIG_IsOK(res1)) {
45933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45934 }
45935 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45936 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45937 if (!SWIG_IsOK(ecode2)) {
45938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45939 }
45940 arg2 = static_cast< unsigned int >(val2);
45941 {
45942 PyThreadState* __tstate = wxPyBeginAllowThreads();
45943 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45944 wxPyEndAllowThreads(__tstate);
45945 if (PyErr_Occurred()) SWIG_fail;
45946 }
45947 {
45948 #if wxUSE_UNICODE
45949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45950 #else
45951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45952 #endif
45953 }
45954 return resultobj;
45955 fail:
45956 return NULL;
45957 }
45958
45959
45960 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45961 PyObject *resultobj = 0;
45962 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45963 wxArrayString result;
45964 void *argp1 = 0 ;
45965 int res1 = 0 ;
45966 PyObject *swig_obj[1] ;
45967
45968 if (!args) SWIG_fail;
45969 swig_obj[0] = args;
45970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45971 if (!SWIG_IsOK(res1)) {
45972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45973 }
45974 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 result = ((wxItemContainer const *)arg1)->GetStrings();
45978 wxPyEndAllowThreads(__tstate);
45979 if (PyErr_Occurred()) SWIG_fail;
45980 }
45981 {
45982 resultobj = wxArrayString2PyList_helper(result);
45983 }
45984 return resultobj;
45985 fail:
45986 return NULL;
45987 }
45988
45989
45990 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45991 PyObject *resultobj = 0;
45992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45993 unsigned int arg2 ;
45994 wxString *arg3 = 0 ;
45995 void *argp1 = 0 ;
45996 int res1 = 0 ;
45997 unsigned int val2 ;
45998 int ecode2 = 0 ;
45999 bool temp3 = false ;
46000 PyObject * obj0 = 0 ;
46001 PyObject * obj1 = 0 ;
46002 PyObject * obj2 = 0 ;
46003 char * kwnames[] = {
46004 (char *) "self",(char *) "n",(char *) "s", NULL
46005 };
46006
46007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46009 if (!SWIG_IsOK(res1)) {
46010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46011 }
46012 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46013 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
46014 if (!SWIG_IsOK(ecode2)) {
46015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
46016 }
46017 arg2 = static_cast< unsigned int >(val2);
46018 {
46019 arg3 = wxString_in_helper(obj2);
46020 if (arg3 == NULL) SWIG_fail;
46021 temp3 = true;
46022 }
46023 {
46024 PyThreadState* __tstate = wxPyBeginAllowThreads();
46025 (arg1)->SetString(arg2,(wxString const &)*arg3);
46026 wxPyEndAllowThreads(__tstate);
46027 if (PyErr_Occurred()) SWIG_fail;
46028 }
46029 resultobj = SWIG_Py_Void();
46030 {
46031 if (temp3)
46032 delete arg3;
46033 }
46034 return resultobj;
46035 fail:
46036 {
46037 if (temp3)
46038 delete arg3;
46039 }
46040 return NULL;
46041 }
46042
46043
46044 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46045 PyObject *resultobj = 0;
46046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46047 wxString *arg2 = 0 ;
46048 int result;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 bool temp2 = false ;
46052 PyObject * obj0 = 0 ;
46053 PyObject * obj1 = 0 ;
46054 char * kwnames[] = {
46055 (char *) "self",(char *) "s", NULL
46056 };
46057
46058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46060 if (!SWIG_IsOK(res1)) {
46061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46062 }
46063 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46064 {
46065 arg2 = wxString_in_helper(obj1);
46066 if (arg2 == NULL) SWIG_fail;
46067 temp2 = true;
46068 }
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 resultobj = SWIG_From_int(static_cast< int >(result));
46076 {
46077 if (temp2)
46078 delete arg2;
46079 }
46080 return resultobj;
46081 fail:
46082 {
46083 if (temp2)
46084 delete arg2;
46085 }
46086 return NULL;
46087 }
46088
46089
46090 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46091 PyObject *resultobj = 0;
46092 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46093 int arg2 ;
46094 void *argp1 = 0 ;
46095 int res1 = 0 ;
46096 int val2 ;
46097 int ecode2 = 0 ;
46098 PyObject * obj0 = 0 ;
46099 PyObject * obj1 = 0 ;
46100 char * kwnames[] = {
46101 (char *) "self",(char *) "n", NULL
46102 };
46103
46104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46106 if (!SWIG_IsOK(res1)) {
46107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46108 }
46109 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46110 ecode2 = SWIG_AsVal_int(obj1, &val2);
46111 if (!SWIG_IsOK(ecode2)) {
46112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46113 }
46114 arg2 = static_cast< int >(val2);
46115 {
46116 PyThreadState* __tstate = wxPyBeginAllowThreads();
46117 (arg1)->SetSelection(arg2);
46118 wxPyEndAllowThreads(__tstate);
46119 if (PyErr_Occurred()) SWIG_fail;
46120 }
46121 resultobj = SWIG_Py_Void();
46122 return resultobj;
46123 fail:
46124 return NULL;
46125 }
46126
46127
46128 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46129 PyObject *resultobj = 0;
46130 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46131 int result;
46132 void *argp1 = 0 ;
46133 int res1 = 0 ;
46134 PyObject *swig_obj[1] ;
46135
46136 if (!args) SWIG_fail;
46137 swig_obj[0] = args;
46138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46139 if (!SWIG_IsOK(res1)) {
46140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46141 }
46142 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46143 {
46144 PyThreadState* __tstate = wxPyBeginAllowThreads();
46145 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46146 wxPyEndAllowThreads(__tstate);
46147 if (PyErr_Occurred()) SWIG_fail;
46148 }
46149 resultobj = SWIG_From_int(static_cast< int >(result));
46150 return resultobj;
46151 fail:
46152 return NULL;
46153 }
46154
46155
46156 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46157 PyObject *resultobj = 0;
46158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46159 wxString *arg2 = 0 ;
46160 bool result;
46161 void *argp1 = 0 ;
46162 int res1 = 0 ;
46163 bool temp2 = false ;
46164 PyObject * obj0 = 0 ;
46165 PyObject * obj1 = 0 ;
46166 char * kwnames[] = {
46167 (char *) "self",(char *) "s", NULL
46168 };
46169
46170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46172 if (!SWIG_IsOK(res1)) {
46173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46174 }
46175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46176 {
46177 arg2 = wxString_in_helper(obj1);
46178 if (arg2 == NULL) SWIG_fail;
46179 temp2 = true;
46180 }
46181 {
46182 PyThreadState* __tstate = wxPyBeginAllowThreads();
46183 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46184 wxPyEndAllowThreads(__tstate);
46185 if (PyErr_Occurred()) SWIG_fail;
46186 }
46187 {
46188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46189 }
46190 {
46191 if (temp2)
46192 delete arg2;
46193 }
46194 return resultobj;
46195 fail:
46196 {
46197 if (temp2)
46198 delete arg2;
46199 }
46200 return NULL;
46201 }
46202
46203
46204 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46205 PyObject *resultobj = 0;
46206 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46207 wxString result;
46208 void *argp1 = 0 ;
46209 int res1 = 0 ;
46210 PyObject *swig_obj[1] ;
46211
46212 if (!args) SWIG_fail;
46213 swig_obj[0] = args;
46214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46215 if (!SWIG_IsOK(res1)) {
46216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46217 }
46218 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 {
46226 #if wxUSE_UNICODE
46227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46228 #else
46229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46230 #endif
46231 }
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46241 int arg2 ;
46242 void *argp1 = 0 ;
46243 int res1 = 0 ;
46244 int val2 ;
46245 int ecode2 = 0 ;
46246 PyObject * obj0 = 0 ;
46247 PyObject * obj1 = 0 ;
46248 char * kwnames[] = {
46249 (char *) "self",(char *) "n", NULL
46250 };
46251
46252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46254 if (!SWIG_IsOK(res1)) {
46255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46256 }
46257 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46258 ecode2 = SWIG_AsVal_int(obj1, &val2);
46259 if (!SWIG_IsOK(ecode2)) {
46260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46261 }
46262 arg2 = static_cast< int >(val2);
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 (arg1)->Select(arg2);
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_Py_Void();
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46277 PyObject *obj;
46278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46279 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46280 return SWIG_Py_Void();
46281 }
46282
46283 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *obj;
46285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46286 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46287 return SWIG_Py_Void();
46288 }
46289
46290 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46291 PyObject *resultobj = 0;
46292 wxSizerItem *result = 0 ;
46293
46294 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 result = (wxSizerItem *)new wxSizerItem();
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46309 PyObject *resultobj = 0;
46310 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 PyObject *swig_obj[1] ;
46314
46315 if (!args) SWIG_fail;
46316 swig_obj[0] = args;
46317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 delete arg1;
46325
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_Py_Void();
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxWindow *arg1 = (wxWindow *) 0 ;
46339 int arg2 ;
46340 int arg3 ;
46341 int arg4 ;
46342 PyObject *arg5 = (PyObject *) NULL ;
46343 wxSizerItem *result = 0 ;
46344 void *argp1 = 0 ;
46345 int res1 = 0 ;
46346 int val2 ;
46347 int ecode2 = 0 ;
46348 int val3 ;
46349 int ecode3 = 0 ;
46350 int val4 ;
46351 int ecode4 = 0 ;
46352 PyObject * obj0 = 0 ;
46353 PyObject * obj1 = 0 ;
46354 PyObject * obj2 = 0 ;
46355 PyObject * obj3 = 0 ;
46356 PyObject * obj4 = 0 ;
46357 char * kwnames[] = {
46358 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46359 };
46360
46361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46363 if (!SWIG_IsOK(res1)) {
46364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46365 }
46366 arg1 = reinterpret_cast< wxWindow * >(argp1);
46367 ecode2 = SWIG_AsVal_int(obj1, &val2);
46368 if (!SWIG_IsOK(ecode2)) {
46369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46370 }
46371 arg2 = static_cast< int >(val2);
46372 ecode3 = SWIG_AsVal_int(obj2, &val3);
46373 if (!SWIG_IsOK(ecode3)) {
46374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46375 }
46376 arg3 = static_cast< int >(val3);
46377 ecode4 = SWIG_AsVal_int(obj3, &val4);
46378 if (!SWIG_IsOK(ecode4)) {
46379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46380 }
46381 arg4 = static_cast< int >(val4);
46382 if (obj4) {
46383 arg5 = obj4;
46384 }
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46399 PyObject *resultobj = 0;
46400 int arg1 ;
46401 int arg2 ;
46402 int arg3 ;
46403 int arg4 ;
46404 int arg5 ;
46405 PyObject *arg6 = (PyObject *) NULL ;
46406 wxSizerItem *result = 0 ;
46407 int val1 ;
46408 int ecode1 = 0 ;
46409 int val2 ;
46410 int ecode2 = 0 ;
46411 int val3 ;
46412 int ecode3 = 0 ;
46413 int val4 ;
46414 int ecode4 = 0 ;
46415 int val5 ;
46416 int ecode5 = 0 ;
46417 PyObject * obj0 = 0 ;
46418 PyObject * obj1 = 0 ;
46419 PyObject * obj2 = 0 ;
46420 PyObject * obj3 = 0 ;
46421 PyObject * obj4 = 0 ;
46422 PyObject * obj5 = 0 ;
46423 char * kwnames[] = {
46424 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46425 };
46426
46427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46428 ecode1 = SWIG_AsVal_int(obj0, &val1);
46429 if (!SWIG_IsOK(ecode1)) {
46430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46431 }
46432 arg1 = static_cast< int >(val1);
46433 ecode2 = SWIG_AsVal_int(obj1, &val2);
46434 if (!SWIG_IsOK(ecode2)) {
46435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46436 }
46437 arg2 = static_cast< int >(val2);
46438 ecode3 = SWIG_AsVal_int(obj2, &val3);
46439 if (!SWIG_IsOK(ecode3)) {
46440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46441 }
46442 arg3 = static_cast< int >(val3);
46443 ecode4 = SWIG_AsVal_int(obj3, &val4);
46444 if (!SWIG_IsOK(ecode4)) {
46445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46446 }
46447 arg4 = static_cast< int >(val4);
46448 ecode5 = SWIG_AsVal_int(obj4, &val5);
46449 if (!SWIG_IsOK(ecode5)) {
46450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46451 }
46452 arg5 = static_cast< int >(val5);
46453 if (obj5) {
46454 arg6 = obj5;
46455 }
46456 {
46457 PyThreadState* __tstate = wxPyBeginAllowThreads();
46458 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46459 wxPyEndAllowThreads(__tstate);
46460 if (PyErr_Occurred()) SWIG_fail;
46461 }
46462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46463 return resultobj;
46464 fail:
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46470 PyObject *resultobj = 0;
46471 wxSizer *arg1 = (wxSizer *) 0 ;
46472 int arg2 ;
46473 int arg3 ;
46474 int arg4 ;
46475 PyObject *arg5 = (PyObject *) NULL ;
46476 wxSizerItem *result = 0 ;
46477 int res1 = 0 ;
46478 int val2 ;
46479 int ecode2 = 0 ;
46480 int val3 ;
46481 int ecode3 = 0 ;
46482 int val4 ;
46483 int ecode4 = 0 ;
46484 PyObject * obj0 = 0 ;
46485 PyObject * obj1 = 0 ;
46486 PyObject * obj2 = 0 ;
46487 PyObject * obj3 = 0 ;
46488 PyObject * obj4 = 0 ;
46489 char * kwnames[] = {
46490 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46491 };
46492
46493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46494 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46495 if (!SWIG_IsOK(res1)) {
46496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46497 }
46498 ecode2 = SWIG_AsVal_int(obj1, &val2);
46499 if (!SWIG_IsOK(ecode2)) {
46500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46501 }
46502 arg2 = static_cast< int >(val2);
46503 ecode3 = SWIG_AsVal_int(obj2, &val3);
46504 if (!SWIG_IsOK(ecode3)) {
46505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46506 }
46507 arg3 = static_cast< int >(val3);
46508 ecode4 = SWIG_AsVal_int(obj3, &val4);
46509 if (!SWIG_IsOK(ecode4)) {
46510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46511 }
46512 arg4 = static_cast< int >(val4);
46513 if (obj4) {
46514 arg5 = obj4;
46515 }
46516 {
46517 PyThreadState* __tstate = wxPyBeginAllowThreads();
46518 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46519 wxPyEndAllowThreads(__tstate);
46520 if (PyErr_Occurred()) SWIG_fail;
46521 }
46522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46523 return resultobj;
46524 fail:
46525 return NULL;
46526 }
46527
46528
46529 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46530 PyObject *resultobj = 0;
46531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 PyObject *swig_obj[1] ;
46535
46536 if (!args) SWIG_fail;
46537 swig_obj[0] = args;
46538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46541 }
46542 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 (arg1)->DeleteWindows();
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_Py_Void();
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46557 PyObject *resultobj = 0;
46558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46559 void *argp1 = 0 ;
46560 int res1 = 0 ;
46561 PyObject *swig_obj[1] ;
46562
46563 if (!args) SWIG_fail;
46564 swig_obj[0] = args;
46565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46566 if (!SWIG_IsOK(res1)) {
46567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46568 }
46569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46570 {
46571 PyThreadState* __tstate = wxPyBeginAllowThreads();
46572 (arg1)->DetachSizer();
46573 wxPyEndAllowThreads(__tstate);
46574 if (PyErr_Occurred()) SWIG_fail;
46575 }
46576 resultobj = SWIG_Py_Void();
46577 return resultobj;
46578 fail:
46579 return NULL;
46580 }
46581
46582
46583 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46584 PyObject *resultobj = 0;
46585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46586 wxSize result;
46587 void *argp1 = 0 ;
46588 int res1 = 0 ;
46589 PyObject *swig_obj[1] ;
46590
46591 if (!args) SWIG_fail;
46592 swig_obj[0] = args;
46593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46598 {
46599 PyThreadState* __tstate = wxPyBeginAllowThreads();
46600 result = (arg1)->GetSize();
46601 wxPyEndAllowThreads(__tstate);
46602 if (PyErr_Occurred()) SWIG_fail;
46603 }
46604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46605 return resultobj;
46606 fail:
46607 return NULL;
46608 }
46609
46610
46611 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46612 PyObject *resultobj = 0;
46613 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46614 wxSize result;
46615 void *argp1 = 0 ;
46616 int res1 = 0 ;
46617 PyObject *swig_obj[1] ;
46618
46619 if (!args) SWIG_fail;
46620 swig_obj[0] = args;
46621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46622 if (!SWIG_IsOK(res1)) {
46623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46624 }
46625 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46626 {
46627 PyThreadState* __tstate = wxPyBeginAllowThreads();
46628 result = (arg1)->CalcMin();
46629 wxPyEndAllowThreads(__tstate);
46630 if (PyErr_Occurred()) SWIG_fail;
46631 }
46632 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46633 return resultobj;
46634 fail:
46635 return NULL;
46636 }
46637
46638
46639 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46640 PyObject *resultobj = 0;
46641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46642 wxPoint *arg2 = 0 ;
46643 wxSize *arg3 = 0 ;
46644 void *argp1 = 0 ;
46645 int res1 = 0 ;
46646 wxPoint temp2 ;
46647 wxSize temp3 ;
46648 PyObject * obj0 = 0 ;
46649 PyObject * obj1 = 0 ;
46650 PyObject * obj2 = 0 ;
46651 char * kwnames[] = {
46652 (char *) "self",(char *) "pos",(char *) "size", NULL
46653 };
46654
46655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46659 }
46660 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46661 {
46662 arg2 = &temp2;
46663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46664 }
46665 {
46666 arg3 = &temp3;
46667 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46668 }
46669 {
46670 PyThreadState* __tstate = wxPyBeginAllowThreads();
46671 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46672 wxPyEndAllowThreads(__tstate);
46673 if (PyErr_Occurred()) SWIG_fail;
46674 }
46675 resultobj = SWIG_Py_Void();
46676 return resultobj;
46677 fail:
46678 return NULL;
46679 }
46680
46681
46682 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46683 PyObject *resultobj = 0;
46684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46685 wxSize result;
46686 void *argp1 = 0 ;
46687 int res1 = 0 ;
46688 PyObject *swig_obj[1] ;
46689
46690 if (!args) SWIG_fail;
46691 swig_obj[0] = args;
46692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46695 }
46696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46697 {
46698 PyThreadState* __tstate = wxPyBeginAllowThreads();
46699 result = (arg1)->GetMinSize();
46700 wxPyEndAllowThreads(__tstate);
46701 if (PyErr_Occurred()) SWIG_fail;
46702 }
46703 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46704 return resultobj;
46705 fail:
46706 return NULL;
46707 }
46708
46709
46710 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46711 PyObject *resultobj = 0;
46712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46713 wxSize result;
46714 void *argp1 = 0 ;
46715 int res1 = 0 ;
46716 PyObject *swig_obj[1] ;
46717
46718 if (!args) SWIG_fail;
46719 swig_obj[0] = args;
46720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46721 if (!SWIG_IsOK(res1)) {
46722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46723 }
46724 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46725 {
46726 PyThreadState* __tstate = wxPyBeginAllowThreads();
46727 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46728 wxPyEndAllowThreads(__tstate);
46729 if (PyErr_Occurred()) SWIG_fail;
46730 }
46731 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46732 return resultobj;
46733 fail:
46734 return NULL;
46735 }
46736
46737
46738 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46739 PyObject *resultobj = 0;
46740 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46741 int arg2 ;
46742 int arg3 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 int val2 ;
46746 int ecode2 = 0 ;
46747 int val3 ;
46748 int ecode3 = 0 ;
46749 PyObject * obj0 = 0 ;
46750 PyObject * obj1 = 0 ;
46751 PyObject * obj2 = 0 ;
46752 char * kwnames[] = {
46753 (char *) "self",(char *) "x",(char *) "y", NULL
46754 };
46755
46756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46758 if (!SWIG_IsOK(res1)) {
46759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46760 }
46761 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46762 ecode2 = SWIG_AsVal_int(obj1, &val2);
46763 if (!SWIG_IsOK(ecode2)) {
46764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46765 }
46766 arg2 = static_cast< int >(val2);
46767 ecode3 = SWIG_AsVal_int(obj2, &val3);
46768 if (!SWIG_IsOK(ecode3)) {
46769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46770 }
46771 arg3 = static_cast< int >(val3);
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 (arg1)->SetInitSize(arg2,arg3);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_Py_Void();
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46788 int arg2 ;
46789 int arg3 ;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 int val2 ;
46793 int ecode2 = 0 ;
46794 int val3 ;
46795 int ecode3 = 0 ;
46796 PyObject * obj0 = 0 ;
46797 PyObject * obj1 = 0 ;
46798 PyObject * obj2 = 0 ;
46799 char * kwnames[] = {
46800 (char *) "self",(char *) "width",(char *) "height", NULL
46801 };
46802
46803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46805 if (!SWIG_IsOK(res1)) {
46806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46807 }
46808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46809 ecode2 = SWIG_AsVal_int(obj1, &val2);
46810 if (!SWIG_IsOK(ecode2)) {
46811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46812 }
46813 arg2 = static_cast< int >(val2);
46814 ecode3 = SWIG_AsVal_int(obj2, &val3);
46815 if (!SWIG_IsOK(ecode3)) {
46816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46817 }
46818 arg3 = static_cast< int >(val3);
46819 {
46820 PyThreadState* __tstate = wxPyBeginAllowThreads();
46821 (arg1)->SetRatio(arg2,arg3);
46822 wxPyEndAllowThreads(__tstate);
46823 if (PyErr_Occurred()) SWIG_fail;
46824 }
46825 resultobj = SWIG_Py_Void();
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46833 PyObject *resultobj = 0;
46834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46835 wxSize *arg2 = 0 ;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 wxSize temp2 ;
46839 PyObject * obj0 = 0 ;
46840 PyObject * obj1 = 0 ;
46841 char * kwnames[] = {
46842 (char *) "self",(char *) "size", NULL
46843 };
46844
46845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46849 }
46850 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46851 {
46852 arg2 = &temp2;
46853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46854 }
46855 {
46856 PyThreadState* __tstate = wxPyBeginAllowThreads();
46857 (arg1)->SetRatio((wxSize const &)*arg2);
46858 wxPyEndAllowThreads(__tstate);
46859 if (PyErr_Occurred()) SWIG_fail;
46860 }
46861 resultobj = SWIG_Py_Void();
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46871 float arg2 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 float val2 ;
46875 int ecode2 = 0 ;
46876 PyObject * obj0 = 0 ;
46877 PyObject * obj1 = 0 ;
46878 char * kwnames[] = {
46879 (char *) "self",(char *) "ratio", NULL
46880 };
46881
46882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46884 if (!SWIG_IsOK(res1)) {
46885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46886 }
46887 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46888 ecode2 = SWIG_AsVal_float(obj1, &val2);
46889 if (!SWIG_IsOK(ecode2)) {
46890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46891 }
46892 arg2 = static_cast< float >(val2);
46893 {
46894 PyThreadState* __tstate = wxPyBeginAllowThreads();
46895 (arg1)->SetRatio(arg2);
46896 wxPyEndAllowThreads(__tstate);
46897 if (PyErr_Occurred()) SWIG_fail;
46898 }
46899 resultobj = SWIG_Py_Void();
46900 return resultobj;
46901 fail:
46902 return NULL;
46903 }
46904
46905
46906 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46907 PyObject *resultobj = 0;
46908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46909 float result;
46910 void *argp1 = 0 ;
46911 int res1 = 0 ;
46912 PyObject *swig_obj[1] ;
46913
46914 if (!args) SWIG_fail;
46915 swig_obj[0] = args;
46916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46917 if (!SWIG_IsOK(res1)) {
46918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46919 }
46920 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 result = (float)(arg1)->GetRatio();
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 resultobj = SWIG_From_float(static_cast< float >(result));
46928 return resultobj;
46929 fail:
46930 return NULL;
46931 }
46932
46933
46934 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46935 PyObject *resultobj = 0;
46936 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46937 wxRect result;
46938 void *argp1 = 0 ;
46939 int res1 = 0 ;
46940 PyObject *swig_obj[1] ;
46941
46942 if (!args) SWIG_fail;
46943 swig_obj[0] = args;
46944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46945 if (!SWIG_IsOK(res1)) {
46946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46947 }
46948 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 result = (arg1)->GetRect();
46952 wxPyEndAllowThreads(__tstate);
46953 if (PyErr_Occurred()) SWIG_fail;
46954 }
46955 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46956 return resultobj;
46957 fail:
46958 return NULL;
46959 }
46960
46961
46962 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46963 PyObject *resultobj = 0;
46964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46965 bool result;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 PyObject *swig_obj[1] ;
46969
46970 if (!args) SWIG_fail;
46971 swig_obj[0] = args;
46972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46973 if (!SWIG_IsOK(res1)) {
46974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46975 }
46976 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46977 {
46978 PyThreadState* __tstate = wxPyBeginAllowThreads();
46979 result = (bool)(arg1)->IsWindow();
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 {
46984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46985 }
46986 return resultobj;
46987 fail:
46988 return NULL;
46989 }
46990
46991
46992 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46993 PyObject *resultobj = 0;
46994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46995 bool result;
46996 void *argp1 = 0 ;
46997 int res1 = 0 ;
46998 PyObject *swig_obj[1] ;
46999
47000 if (!args) SWIG_fail;
47001 swig_obj[0] = args;
47002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47007 {
47008 PyThreadState* __tstate = wxPyBeginAllowThreads();
47009 result = (bool)(arg1)->IsSizer();
47010 wxPyEndAllowThreads(__tstate);
47011 if (PyErr_Occurred()) SWIG_fail;
47012 }
47013 {
47014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47015 }
47016 return resultobj;
47017 fail:
47018 return NULL;
47019 }
47020
47021
47022 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47023 PyObject *resultobj = 0;
47024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47025 bool result;
47026 void *argp1 = 0 ;
47027 int res1 = 0 ;
47028 PyObject *swig_obj[1] ;
47029
47030 if (!args) SWIG_fail;
47031 swig_obj[0] = args;
47032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47033 if (!SWIG_IsOK(res1)) {
47034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47035 }
47036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47037 {
47038 PyThreadState* __tstate = wxPyBeginAllowThreads();
47039 result = (bool)(arg1)->IsSpacer();
47040 wxPyEndAllowThreads(__tstate);
47041 if (PyErr_Occurred()) SWIG_fail;
47042 }
47043 {
47044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47045 }
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47053 PyObject *resultobj = 0;
47054 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47055 int arg2 ;
47056 void *argp1 = 0 ;
47057 int res1 = 0 ;
47058 int val2 ;
47059 int ecode2 = 0 ;
47060 PyObject * obj0 = 0 ;
47061 PyObject * obj1 = 0 ;
47062 char * kwnames[] = {
47063 (char *) "self",(char *) "proportion", NULL
47064 };
47065
47066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47070 }
47071 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47072 ecode2 = SWIG_AsVal_int(obj1, &val2);
47073 if (!SWIG_IsOK(ecode2)) {
47074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47075 }
47076 arg2 = static_cast< int >(val2);
47077 {
47078 PyThreadState* __tstate = wxPyBeginAllowThreads();
47079 (arg1)->SetProportion(arg2);
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 resultobj = SWIG_Py_Void();
47084 return resultobj;
47085 fail:
47086 return NULL;
47087 }
47088
47089
47090 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47091 PyObject *resultobj = 0;
47092 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47093 int result;
47094 void *argp1 = 0 ;
47095 int res1 = 0 ;
47096 PyObject *swig_obj[1] ;
47097
47098 if (!args) SWIG_fail;
47099 swig_obj[0] = args;
47100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47101 if (!SWIG_IsOK(res1)) {
47102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47103 }
47104 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47105 {
47106 PyThreadState* __tstate = wxPyBeginAllowThreads();
47107 result = (int)(arg1)->GetProportion();
47108 wxPyEndAllowThreads(__tstate);
47109 if (PyErr_Occurred()) SWIG_fail;
47110 }
47111 resultobj = SWIG_From_int(static_cast< int >(result));
47112 return resultobj;
47113 fail:
47114 return NULL;
47115 }
47116
47117
47118 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47119 PyObject *resultobj = 0;
47120 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47121 int arg2 ;
47122 void *argp1 = 0 ;
47123 int res1 = 0 ;
47124 int val2 ;
47125 int ecode2 = 0 ;
47126 PyObject * obj0 = 0 ;
47127 PyObject * obj1 = 0 ;
47128 char * kwnames[] = {
47129 (char *) "self",(char *) "flag", NULL
47130 };
47131
47132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47134 if (!SWIG_IsOK(res1)) {
47135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47136 }
47137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47138 ecode2 = SWIG_AsVal_int(obj1, &val2);
47139 if (!SWIG_IsOK(ecode2)) {
47140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47141 }
47142 arg2 = static_cast< int >(val2);
47143 {
47144 PyThreadState* __tstate = wxPyBeginAllowThreads();
47145 (arg1)->SetFlag(arg2);
47146 wxPyEndAllowThreads(__tstate);
47147 if (PyErr_Occurred()) SWIG_fail;
47148 }
47149 resultobj = SWIG_Py_Void();
47150 return resultobj;
47151 fail:
47152 return NULL;
47153 }
47154
47155
47156 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47157 PyObject *resultobj = 0;
47158 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47159 int result;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 PyObject *swig_obj[1] ;
47163
47164 if (!args) SWIG_fail;
47165 swig_obj[0] = args;
47166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47167 if (!SWIG_IsOK(res1)) {
47168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47169 }
47170 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 result = (int)(arg1)->GetFlag();
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_From_int(static_cast< int >(result));
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47185 PyObject *resultobj = 0;
47186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47187 int arg2 ;
47188 void *argp1 = 0 ;
47189 int res1 = 0 ;
47190 int val2 ;
47191 int ecode2 = 0 ;
47192 PyObject * obj0 = 0 ;
47193 PyObject * obj1 = 0 ;
47194 char * kwnames[] = {
47195 (char *) "self",(char *) "border", NULL
47196 };
47197
47198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47200 if (!SWIG_IsOK(res1)) {
47201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47202 }
47203 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47204 ecode2 = SWIG_AsVal_int(obj1, &val2);
47205 if (!SWIG_IsOK(ecode2)) {
47206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47207 }
47208 arg2 = static_cast< int >(val2);
47209 {
47210 PyThreadState* __tstate = wxPyBeginAllowThreads();
47211 (arg1)->SetBorder(arg2);
47212 wxPyEndAllowThreads(__tstate);
47213 if (PyErr_Occurred()) SWIG_fail;
47214 }
47215 resultobj = SWIG_Py_Void();
47216 return resultobj;
47217 fail:
47218 return NULL;
47219 }
47220
47221
47222 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47223 PyObject *resultobj = 0;
47224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47225 int result;
47226 void *argp1 = 0 ;
47227 int res1 = 0 ;
47228 PyObject *swig_obj[1] ;
47229
47230 if (!args) SWIG_fail;
47231 swig_obj[0] = args;
47232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47233 if (!SWIG_IsOK(res1)) {
47234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47235 }
47236 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47237 {
47238 PyThreadState* __tstate = wxPyBeginAllowThreads();
47239 result = (int)(arg1)->GetBorder();
47240 wxPyEndAllowThreads(__tstate);
47241 if (PyErr_Occurred()) SWIG_fail;
47242 }
47243 resultobj = SWIG_From_int(static_cast< int >(result));
47244 return resultobj;
47245 fail:
47246 return NULL;
47247 }
47248
47249
47250 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47251 PyObject *resultobj = 0;
47252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47253 wxWindow *result = 0 ;
47254 void *argp1 = 0 ;
47255 int res1 = 0 ;
47256 PyObject *swig_obj[1] ;
47257
47258 if (!args) SWIG_fail;
47259 swig_obj[0] = args;
47260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47261 if (!SWIG_IsOK(res1)) {
47262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47263 }
47264 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 result = (wxWindow *)(arg1)->GetWindow();
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 {
47272 resultobj = wxPyMake_wxObject(result, 0);
47273 }
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47283 wxWindow *arg2 = (wxWindow *) 0 ;
47284 void *argp1 = 0 ;
47285 int res1 = 0 ;
47286 void *argp2 = 0 ;
47287 int res2 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 PyObject * obj1 = 0 ;
47290 char * kwnames[] = {
47291 (char *) "self",(char *) "window", NULL
47292 };
47293
47294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47298 }
47299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47301 if (!SWIG_IsOK(res2)) {
47302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47303 }
47304 arg2 = reinterpret_cast< wxWindow * >(argp2);
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 (arg1)->SetWindow(arg2);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47319 PyObject *resultobj = 0;
47320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47321 wxSizer *result = 0 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 PyObject *swig_obj[1] ;
47325
47326 if (!args) SWIG_fail;
47327 swig_obj[0] = args;
47328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47329 if (!SWIG_IsOK(res1)) {
47330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47331 }
47332 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47333 {
47334 PyThreadState* __tstate = wxPyBeginAllowThreads();
47335 result = (wxSizer *)(arg1)->GetSizer();
47336 wxPyEndAllowThreads(__tstate);
47337 if (PyErr_Occurred()) SWIG_fail;
47338 }
47339 {
47340 resultobj = wxPyMake_wxObject(result, (bool)0);
47341 }
47342 return resultobj;
47343 fail:
47344 return NULL;
47345 }
47346
47347
47348 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47349 PyObject *resultobj = 0;
47350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47351 wxSizer *arg2 = (wxSizer *) 0 ;
47352 void *argp1 = 0 ;
47353 int res1 = 0 ;
47354 int res2 = 0 ;
47355 PyObject * obj0 = 0 ;
47356 PyObject * obj1 = 0 ;
47357 char * kwnames[] = {
47358 (char *) "self",(char *) "sizer", NULL
47359 };
47360
47361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47363 if (!SWIG_IsOK(res1)) {
47364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47365 }
47366 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47367 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47368 if (!SWIG_IsOK(res2)) {
47369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47370 }
47371 {
47372 PyThreadState* __tstate = wxPyBeginAllowThreads();
47373 (arg1)->SetSizer(arg2);
47374 wxPyEndAllowThreads(__tstate);
47375 if (PyErr_Occurred()) SWIG_fail;
47376 }
47377 resultobj = SWIG_Py_Void();
47378 return resultobj;
47379 fail:
47380 return NULL;
47381 }
47382
47383
47384 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47385 PyObject *resultobj = 0;
47386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47387 wxSize *result = 0 ;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 PyObject *swig_obj[1] ;
47391
47392 if (!args) SWIG_fail;
47393 swig_obj[0] = args;
47394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47395 if (!SWIG_IsOK(res1)) {
47396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47397 }
47398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47399 {
47400 PyThreadState* __tstate = wxPyBeginAllowThreads();
47401 {
47402 wxSize const &_result_ref = (arg1)->GetSpacer();
47403 result = (wxSize *) &_result_ref;
47404 }
47405 wxPyEndAllowThreads(__tstate);
47406 if (PyErr_Occurred()) SWIG_fail;
47407 }
47408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
47409 return resultobj;
47410 fail:
47411 return NULL;
47412 }
47413
47414
47415 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47416 PyObject *resultobj = 0;
47417 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47418 wxSize *arg2 = 0 ;
47419 void *argp1 = 0 ;
47420 int res1 = 0 ;
47421 wxSize temp2 ;
47422 PyObject * obj0 = 0 ;
47423 PyObject * obj1 = 0 ;
47424 char * kwnames[] = {
47425 (char *) "self",(char *) "size", NULL
47426 };
47427
47428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47430 if (!SWIG_IsOK(res1)) {
47431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47432 }
47433 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47434 {
47435 arg2 = &temp2;
47436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47437 }
47438 {
47439 PyThreadState* __tstate = wxPyBeginAllowThreads();
47440 (arg1)->SetSpacer((wxSize const &)*arg2);
47441 wxPyEndAllowThreads(__tstate);
47442 if (PyErr_Occurred()) SWIG_fail;
47443 }
47444 resultobj = SWIG_Py_Void();
47445 return resultobj;
47446 fail:
47447 return NULL;
47448 }
47449
47450
47451 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47452 PyObject *resultobj = 0;
47453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47454 bool arg2 ;
47455 void *argp1 = 0 ;
47456 int res1 = 0 ;
47457 bool val2 ;
47458 int ecode2 = 0 ;
47459 PyObject * obj0 = 0 ;
47460 PyObject * obj1 = 0 ;
47461 char * kwnames[] = {
47462 (char *) "self",(char *) "show", NULL
47463 };
47464
47465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47467 if (!SWIG_IsOK(res1)) {
47468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47469 }
47470 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47471 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47472 if (!SWIG_IsOK(ecode2)) {
47473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47474 }
47475 arg2 = static_cast< bool >(val2);
47476 {
47477 PyThreadState* __tstate = wxPyBeginAllowThreads();
47478 (arg1)->Show(arg2);
47479 wxPyEndAllowThreads(__tstate);
47480 if (PyErr_Occurred()) SWIG_fail;
47481 }
47482 resultobj = SWIG_Py_Void();
47483 return resultobj;
47484 fail:
47485 return NULL;
47486 }
47487
47488
47489 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47490 PyObject *resultobj = 0;
47491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47492 bool result;
47493 void *argp1 = 0 ;
47494 int res1 = 0 ;
47495 PyObject *swig_obj[1] ;
47496
47497 if (!args) SWIG_fail;
47498 swig_obj[0] = args;
47499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47500 if (!SWIG_IsOK(res1)) {
47501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47502 }
47503 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47504 {
47505 PyThreadState* __tstate = wxPyBeginAllowThreads();
47506 result = (bool)(arg1)->IsShown();
47507 wxPyEndAllowThreads(__tstate);
47508 if (PyErr_Occurred()) SWIG_fail;
47509 }
47510 {
47511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47512 }
47513 return resultobj;
47514 fail:
47515 return NULL;
47516 }
47517
47518
47519 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47520 PyObject *resultobj = 0;
47521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47522 wxPoint result;
47523 void *argp1 = 0 ;
47524 int res1 = 0 ;
47525 PyObject *swig_obj[1] ;
47526
47527 if (!args) SWIG_fail;
47528 swig_obj[0] = args;
47529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47530 if (!SWIG_IsOK(res1)) {
47531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47532 }
47533 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 result = (arg1)->GetPosition();
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47548 PyObject *resultobj = 0;
47549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47550 PyObject *result = 0 ;
47551 void *argp1 = 0 ;
47552 int res1 = 0 ;
47553 PyObject *swig_obj[1] ;
47554
47555 if (!args) SWIG_fail;
47556 swig_obj[0] = args;
47557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47558 if (!SWIG_IsOK(res1)) {
47559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47560 }
47561 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = result;
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47576 PyObject *resultobj = 0;
47577 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47578 PyObject *arg2 = (PyObject *) 0 ;
47579 void *argp1 = 0 ;
47580 int res1 = 0 ;
47581 PyObject * obj0 = 0 ;
47582 PyObject * obj1 = 0 ;
47583 char * kwnames[] = {
47584 (char *) "self",(char *) "userData", NULL
47585 };
47586
47587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47589 if (!SWIG_IsOK(res1)) {
47590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47591 }
47592 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47593 arg2 = obj1;
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 wxSizerItem_SetUserData(arg1,arg2);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *obj;
47609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47610 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47611 return SWIG_Py_Void();
47612 }
47613
47614 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47615 return SWIG_Python_InitShadowInstance(args);
47616 }
47617
47618 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47619 PyObject *resultobj = 0;
47620 wxSizer *arg1 = (wxSizer *) 0 ;
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_wxSizer, SWIG_POINTER_DISOWN | 0 );
47628 if (!SWIG_IsOK(res1)) {
47629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47630 }
47631 arg1 = reinterpret_cast< wxSizer * >(argp1);
47632 {
47633 PyThreadState* __tstate = wxPyBeginAllowThreads();
47634 delete arg1;
47635
47636 wxPyEndAllowThreads(__tstate);
47637 if (PyErr_Occurred()) SWIG_fail;
47638 }
47639 resultobj = SWIG_Py_Void();
47640 return resultobj;
47641 fail:
47642 return NULL;
47643 }
47644
47645
47646 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47647 PyObject *resultobj = 0;
47648 wxSizer *arg1 = (wxSizer *) 0 ;
47649 PyObject *arg2 = (PyObject *) 0 ;
47650 void *argp1 = 0 ;
47651 int res1 = 0 ;
47652 PyObject * obj0 = 0 ;
47653 PyObject * obj1 = 0 ;
47654 char * kwnames[] = {
47655 (char *) "self",(char *) "_self", NULL
47656 };
47657
47658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47660 if (!SWIG_IsOK(res1)) {
47661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47662 }
47663 arg1 = reinterpret_cast< wxSizer * >(argp1);
47664 arg2 = obj1;
47665 {
47666 PyThreadState* __tstate = wxPyBeginAllowThreads();
47667 wxSizer__setOORInfo(arg1,arg2);
47668 wxPyEndAllowThreads(__tstate);
47669 if (PyErr_Occurred()) SWIG_fail;
47670 }
47671 resultobj = SWIG_Py_Void();
47672 return resultobj;
47673 fail:
47674 return NULL;
47675 }
47676
47677
47678 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47679 PyObject *resultobj = 0;
47680 wxSizer *arg1 = (wxSizer *) 0 ;
47681 PyObject *arg2 = (PyObject *) 0 ;
47682 int arg3 = (int) 0 ;
47683 int arg4 = (int) 0 ;
47684 int arg5 = (int) 0 ;
47685 PyObject *arg6 = (PyObject *) NULL ;
47686 wxSizerItem *result = 0 ;
47687 void *argp1 = 0 ;
47688 int res1 = 0 ;
47689 int val3 ;
47690 int ecode3 = 0 ;
47691 int val4 ;
47692 int ecode4 = 0 ;
47693 int val5 ;
47694 int ecode5 = 0 ;
47695 PyObject * obj0 = 0 ;
47696 PyObject * obj1 = 0 ;
47697 PyObject * obj2 = 0 ;
47698 PyObject * obj3 = 0 ;
47699 PyObject * obj4 = 0 ;
47700 PyObject * obj5 = 0 ;
47701 char * kwnames[] = {
47702 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47703 };
47704
47705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47707 if (!SWIG_IsOK(res1)) {
47708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47709 }
47710 arg1 = reinterpret_cast< wxSizer * >(argp1);
47711 arg2 = obj1;
47712 if (obj2) {
47713 ecode3 = SWIG_AsVal_int(obj2, &val3);
47714 if (!SWIG_IsOK(ecode3)) {
47715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47716 }
47717 arg3 = static_cast< int >(val3);
47718 }
47719 if (obj3) {
47720 ecode4 = SWIG_AsVal_int(obj3, &val4);
47721 if (!SWIG_IsOK(ecode4)) {
47722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47723 }
47724 arg4 = static_cast< int >(val4);
47725 }
47726 if (obj4) {
47727 ecode5 = SWIG_AsVal_int(obj4, &val5);
47728 if (!SWIG_IsOK(ecode5)) {
47729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47730 }
47731 arg5 = static_cast< int >(val5);
47732 }
47733 if (obj5) {
47734 arg6 = obj5;
47735 }
47736 {
47737 PyThreadState* __tstate = wxPyBeginAllowThreads();
47738 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47739 wxPyEndAllowThreads(__tstate);
47740 if (PyErr_Occurred()) SWIG_fail;
47741 }
47742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47743 return resultobj;
47744 fail:
47745 return NULL;
47746 }
47747
47748
47749 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47750 PyObject *resultobj = 0;
47751 wxSizer *arg1 = (wxSizer *) 0 ;
47752 int arg2 ;
47753 PyObject *arg3 = (PyObject *) 0 ;
47754 int arg4 = (int) 0 ;
47755 int arg5 = (int) 0 ;
47756 int arg6 = (int) 0 ;
47757 PyObject *arg7 = (PyObject *) NULL ;
47758 wxSizerItem *result = 0 ;
47759 void *argp1 = 0 ;
47760 int res1 = 0 ;
47761 int val2 ;
47762 int ecode2 = 0 ;
47763 int val4 ;
47764 int ecode4 = 0 ;
47765 int val5 ;
47766 int ecode5 = 0 ;
47767 int val6 ;
47768 int ecode6 = 0 ;
47769 PyObject * obj0 = 0 ;
47770 PyObject * obj1 = 0 ;
47771 PyObject * obj2 = 0 ;
47772 PyObject * obj3 = 0 ;
47773 PyObject * obj4 = 0 ;
47774 PyObject * obj5 = 0 ;
47775 PyObject * obj6 = 0 ;
47776 char * kwnames[] = {
47777 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47778 };
47779
47780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47782 if (!SWIG_IsOK(res1)) {
47783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47784 }
47785 arg1 = reinterpret_cast< wxSizer * >(argp1);
47786 ecode2 = SWIG_AsVal_int(obj1, &val2);
47787 if (!SWIG_IsOK(ecode2)) {
47788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47789 }
47790 arg2 = static_cast< int >(val2);
47791 arg3 = obj2;
47792 if (obj3) {
47793 ecode4 = SWIG_AsVal_int(obj3, &val4);
47794 if (!SWIG_IsOK(ecode4)) {
47795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47796 }
47797 arg4 = static_cast< int >(val4);
47798 }
47799 if (obj4) {
47800 ecode5 = SWIG_AsVal_int(obj4, &val5);
47801 if (!SWIG_IsOK(ecode5)) {
47802 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47803 }
47804 arg5 = static_cast< int >(val5);
47805 }
47806 if (obj5) {
47807 ecode6 = SWIG_AsVal_int(obj5, &val6);
47808 if (!SWIG_IsOK(ecode6)) {
47809 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47810 }
47811 arg6 = static_cast< int >(val6);
47812 }
47813 if (obj6) {
47814 arg7 = obj6;
47815 }
47816 {
47817 PyThreadState* __tstate = wxPyBeginAllowThreads();
47818 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47819 wxPyEndAllowThreads(__tstate);
47820 if (PyErr_Occurred()) SWIG_fail;
47821 }
47822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47823 return resultobj;
47824 fail:
47825 return NULL;
47826 }
47827
47828
47829 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47830 PyObject *resultobj = 0;
47831 wxSizer *arg1 = (wxSizer *) 0 ;
47832 PyObject *arg2 = (PyObject *) 0 ;
47833 int arg3 = (int) 0 ;
47834 int arg4 = (int) 0 ;
47835 int arg5 = (int) 0 ;
47836 PyObject *arg6 = (PyObject *) NULL ;
47837 wxSizerItem *result = 0 ;
47838 void *argp1 = 0 ;
47839 int res1 = 0 ;
47840 int val3 ;
47841 int ecode3 = 0 ;
47842 int val4 ;
47843 int ecode4 = 0 ;
47844 int val5 ;
47845 int ecode5 = 0 ;
47846 PyObject * obj0 = 0 ;
47847 PyObject * obj1 = 0 ;
47848 PyObject * obj2 = 0 ;
47849 PyObject * obj3 = 0 ;
47850 PyObject * obj4 = 0 ;
47851 PyObject * obj5 = 0 ;
47852 char * kwnames[] = {
47853 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47854 };
47855
47856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47858 if (!SWIG_IsOK(res1)) {
47859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47860 }
47861 arg1 = reinterpret_cast< wxSizer * >(argp1);
47862 arg2 = obj1;
47863 if (obj2) {
47864 ecode3 = SWIG_AsVal_int(obj2, &val3);
47865 if (!SWIG_IsOK(ecode3)) {
47866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47867 }
47868 arg3 = static_cast< int >(val3);
47869 }
47870 if (obj3) {
47871 ecode4 = SWIG_AsVal_int(obj3, &val4);
47872 if (!SWIG_IsOK(ecode4)) {
47873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47874 }
47875 arg4 = static_cast< int >(val4);
47876 }
47877 if (obj4) {
47878 ecode5 = SWIG_AsVal_int(obj4, &val5);
47879 if (!SWIG_IsOK(ecode5)) {
47880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47881 }
47882 arg5 = static_cast< int >(val5);
47883 }
47884 if (obj5) {
47885 arg6 = obj5;
47886 }
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47901 PyObject *resultobj = 0;
47902 wxSizer *arg1 = (wxSizer *) 0 ;
47903 PyObject *arg2 = (PyObject *) 0 ;
47904 bool result;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 PyObject * obj0 = 0 ;
47908 PyObject * obj1 = 0 ;
47909 char * kwnames[] = {
47910 (char *) "self",(char *) "item", NULL
47911 };
47912
47913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47915 if (!SWIG_IsOK(res1)) {
47916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47917 }
47918 arg1 = reinterpret_cast< wxSizer * >(argp1);
47919 arg2 = obj1;
47920 {
47921 PyThreadState* __tstate = wxPyBeginAllowThreads();
47922 result = (bool)wxSizer_Remove(arg1,arg2);
47923 wxPyEndAllowThreads(__tstate);
47924 if (PyErr_Occurred()) SWIG_fail;
47925 }
47926 {
47927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47928 }
47929 return resultobj;
47930 fail:
47931 return NULL;
47932 }
47933
47934
47935 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47936 PyObject *resultobj = 0;
47937 wxSizer *arg1 = (wxSizer *) 0 ;
47938 PyObject *arg2 = (PyObject *) 0 ;
47939 bool result;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 PyObject * obj0 = 0 ;
47943 PyObject * obj1 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "item", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47952 }
47953 arg1 = reinterpret_cast< wxSizer * >(argp1);
47954 arg2 = obj1;
47955 {
47956 PyThreadState* __tstate = wxPyBeginAllowThreads();
47957 result = (bool)wxSizer_Detach(arg1,arg2);
47958 wxPyEndAllowThreads(__tstate);
47959 if (PyErr_Occurred()) SWIG_fail;
47960 }
47961 {
47962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47963 }
47964 return resultobj;
47965 fail:
47966 return NULL;
47967 }
47968
47969
47970 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47971 PyObject *resultobj = 0;
47972 wxSizer *arg1 = (wxSizer *) 0 ;
47973 PyObject *arg2 = (PyObject *) 0 ;
47974 wxSizerItem *result = 0 ;
47975 void *argp1 = 0 ;
47976 int res1 = 0 ;
47977 PyObject * obj0 = 0 ;
47978 PyObject * obj1 = 0 ;
47979 char * kwnames[] = {
47980 (char *) "self",(char *) "item", NULL
47981 };
47982
47983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47985 if (!SWIG_IsOK(res1)) {
47986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47987 }
47988 arg1 = reinterpret_cast< wxSizer * >(argp1);
47989 arg2 = obj1;
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47997 return resultobj;
47998 fail:
47999 return NULL;
48000 }
48001
48002
48003 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48004 PyObject *resultobj = 0;
48005 wxSizer *arg1 = (wxSizer *) 0 ;
48006 PyObject *arg2 = (PyObject *) 0 ;
48007 wxSize *arg3 = 0 ;
48008 void *argp1 = 0 ;
48009 int res1 = 0 ;
48010 wxSize temp3 ;
48011 PyObject * obj0 = 0 ;
48012 PyObject * obj1 = 0 ;
48013 PyObject * obj2 = 0 ;
48014 char * kwnames[] = {
48015 (char *) "self",(char *) "item",(char *) "size", NULL
48016 };
48017
48018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48020 if (!SWIG_IsOK(res1)) {
48021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48022 }
48023 arg1 = reinterpret_cast< wxSizer * >(argp1);
48024 arg2 = obj1;
48025 {
48026 arg3 = &temp3;
48027 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48028 }
48029 {
48030 PyThreadState* __tstate = wxPyBeginAllowThreads();
48031 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48032 wxPyEndAllowThreads(__tstate);
48033 if (PyErr_Occurred()) SWIG_fail;
48034 }
48035 resultobj = SWIG_Py_Void();
48036 return resultobj;
48037 fail:
48038 return NULL;
48039 }
48040
48041
48042 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48043 PyObject *resultobj = 0;
48044 wxSizer *arg1 = (wxSizer *) 0 ;
48045 wxWindow *arg2 = (wxWindow *) 0 ;
48046 wxWindow *arg3 = (wxWindow *) 0 ;
48047 bool arg4 = (bool) false ;
48048 bool result;
48049 void *argp1 = 0 ;
48050 int res1 = 0 ;
48051 void *argp2 = 0 ;
48052 int res2 = 0 ;
48053 void *argp3 = 0 ;
48054 int res3 = 0 ;
48055 bool val4 ;
48056 int ecode4 = 0 ;
48057 PyObject * obj0 = 0 ;
48058 PyObject * obj1 = 0 ;
48059 PyObject * obj2 = 0 ;
48060 PyObject * obj3 = 0 ;
48061 char * kwnames[] = {
48062 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48063 };
48064
48065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48067 if (!SWIG_IsOK(res1)) {
48068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48069 }
48070 arg1 = reinterpret_cast< wxSizer * >(argp1);
48071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48072 if (!SWIG_IsOK(res2)) {
48073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48074 }
48075 arg2 = reinterpret_cast< wxWindow * >(argp2);
48076 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48077 if (!SWIG_IsOK(res3)) {
48078 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48079 }
48080 arg3 = reinterpret_cast< wxWindow * >(argp3);
48081 if (obj3) {
48082 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48083 if (!SWIG_IsOK(ecode4)) {
48084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48085 }
48086 arg4 = static_cast< bool >(val4);
48087 }
48088 {
48089 PyThreadState* __tstate = wxPyBeginAllowThreads();
48090 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48091 wxPyEndAllowThreads(__tstate);
48092 if (PyErr_Occurred()) SWIG_fail;
48093 }
48094 {
48095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48096 }
48097 return resultobj;
48098 fail:
48099 return NULL;
48100 }
48101
48102
48103 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48104 PyObject *resultobj = 0;
48105 wxSizer *arg1 = (wxSizer *) 0 ;
48106 wxSizer *arg2 = (wxSizer *) 0 ;
48107 wxSizer *arg3 = (wxSizer *) 0 ;
48108 bool arg4 = (bool) false ;
48109 bool result;
48110 void *argp1 = 0 ;
48111 int res1 = 0 ;
48112 void *argp2 = 0 ;
48113 int res2 = 0 ;
48114 void *argp3 = 0 ;
48115 int res3 = 0 ;
48116 bool val4 ;
48117 int ecode4 = 0 ;
48118 PyObject * obj0 = 0 ;
48119 PyObject * obj1 = 0 ;
48120 PyObject * obj2 = 0 ;
48121 PyObject * obj3 = 0 ;
48122 char * kwnames[] = {
48123 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48124 };
48125
48126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48128 if (!SWIG_IsOK(res1)) {
48129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48130 }
48131 arg1 = reinterpret_cast< wxSizer * >(argp1);
48132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48133 if (!SWIG_IsOK(res2)) {
48134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48135 }
48136 arg2 = reinterpret_cast< wxSizer * >(argp2);
48137 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48138 if (!SWIG_IsOK(res3)) {
48139 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48140 }
48141 arg3 = reinterpret_cast< wxSizer * >(argp3);
48142 if (obj3) {
48143 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48144 if (!SWIG_IsOK(ecode4)) {
48145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48146 }
48147 arg4 = static_cast< bool >(val4);
48148 }
48149 {
48150 PyThreadState* __tstate = wxPyBeginAllowThreads();
48151 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48152 wxPyEndAllowThreads(__tstate);
48153 if (PyErr_Occurred()) SWIG_fail;
48154 }
48155 {
48156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48157 }
48158 return resultobj;
48159 fail:
48160 return NULL;
48161 }
48162
48163
48164 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48165 PyObject *resultobj = 0;
48166 wxSizer *arg1 = (wxSizer *) 0 ;
48167 size_t arg2 ;
48168 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48169 bool result;
48170 void *argp1 = 0 ;
48171 int res1 = 0 ;
48172 size_t val2 ;
48173 int ecode2 = 0 ;
48174 void *argp3 = 0 ;
48175 int res3 = 0 ;
48176 PyObject * obj0 = 0 ;
48177 PyObject * obj1 = 0 ;
48178 PyObject * obj2 = 0 ;
48179 char * kwnames[] = {
48180 (char *) "self",(char *) "index",(char *) "newitem", NULL
48181 };
48182
48183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48185 if (!SWIG_IsOK(res1)) {
48186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48187 }
48188 arg1 = reinterpret_cast< wxSizer * >(argp1);
48189 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48190 if (!SWIG_IsOK(ecode2)) {
48191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48192 }
48193 arg2 = static_cast< size_t >(val2);
48194 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48195 if (!SWIG_IsOK(res3)) {
48196 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48197 }
48198 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48199 {
48200 PyThreadState* __tstate = wxPyBeginAllowThreads();
48201 result = (bool)(arg1)->Replace(arg2,arg3);
48202 wxPyEndAllowThreads(__tstate);
48203 if (PyErr_Occurred()) SWIG_fail;
48204 }
48205 {
48206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48207 }
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxSizer *arg1 = (wxSizer *) 0 ;
48217 wxWindow *arg2 = (wxWindow *) 0 ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 void *argp2 = 0 ;
48221 int res2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "window", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxSizer * >(argp1);
48234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48235 if (!SWIG_IsOK(res2)) {
48236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48237 }
48238 arg2 = reinterpret_cast< wxWindow * >(argp2);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->SetContainingWindow(arg2);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48253 PyObject *resultobj = 0;
48254 wxSizer *arg1 = (wxSizer *) 0 ;
48255 wxWindow *result = 0 ;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 PyObject *swig_obj[1] ;
48259
48260 if (!args) SWIG_fail;
48261 swig_obj[0] = args;
48262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48265 }
48266 arg1 = reinterpret_cast< wxSizer * >(argp1);
48267 {
48268 PyThreadState* __tstate = wxPyBeginAllowThreads();
48269 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48270 wxPyEndAllowThreads(__tstate);
48271 if (PyErr_Occurred()) SWIG_fail;
48272 }
48273 {
48274 resultobj = wxPyMake_wxObject(result, 0);
48275 }
48276 return resultobj;
48277 fail:
48278 return NULL;
48279 }
48280
48281
48282 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48283 PyObject *resultobj = 0;
48284 wxSizer *arg1 = (wxSizer *) 0 ;
48285 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48286 wxSizerItem *result = 0 ;
48287 void *argp1 = 0 ;
48288 int res1 = 0 ;
48289 int res2 = 0 ;
48290 PyObject * obj0 = 0 ;
48291 PyObject * obj1 = 0 ;
48292 char * kwnames[] = {
48293 (char *) "self",(char *) "item", NULL
48294 };
48295
48296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48298 if (!SWIG_IsOK(res1)) {
48299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48300 }
48301 arg1 = reinterpret_cast< wxSizer * >(argp1);
48302 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48303 if (!SWIG_IsOK(res2)) {
48304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48305 }
48306 {
48307 PyThreadState* __tstate = wxPyBeginAllowThreads();
48308 result = (wxSizerItem *)(arg1)->Add(arg2);
48309 wxPyEndAllowThreads(__tstate);
48310 if (PyErr_Occurred()) SWIG_fail;
48311 }
48312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48313 return resultobj;
48314 fail:
48315 return NULL;
48316 }
48317
48318
48319 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48320 PyObject *resultobj = 0;
48321 wxSizer *arg1 = (wxSizer *) 0 ;
48322 size_t arg2 ;
48323 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48324 wxSizerItem *result = 0 ;
48325 void *argp1 = 0 ;
48326 int res1 = 0 ;
48327 size_t val2 ;
48328 int ecode2 = 0 ;
48329 int res3 = 0 ;
48330 PyObject * obj0 = 0 ;
48331 PyObject * obj1 = 0 ;
48332 PyObject * obj2 = 0 ;
48333 char * kwnames[] = {
48334 (char *) "self",(char *) "index",(char *) "item", NULL
48335 };
48336
48337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48339 if (!SWIG_IsOK(res1)) {
48340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48341 }
48342 arg1 = reinterpret_cast< wxSizer * >(argp1);
48343 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48344 if (!SWIG_IsOK(ecode2)) {
48345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48346 }
48347 arg2 = static_cast< size_t >(val2);
48348 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48349 if (!SWIG_IsOK(res3)) {
48350 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48351 }
48352 {
48353 PyThreadState* __tstate = wxPyBeginAllowThreads();
48354 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48355 wxPyEndAllowThreads(__tstate);
48356 if (PyErr_Occurred()) SWIG_fail;
48357 }
48358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48359 return resultobj;
48360 fail:
48361 return NULL;
48362 }
48363
48364
48365 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48366 PyObject *resultobj = 0;
48367 wxSizer *arg1 = (wxSizer *) 0 ;
48368 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48369 wxSizerItem *result = 0 ;
48370 void *argp1 = 0 ;
48371 int res1 = 0 ;
48372 int res2 = 0 ;
48373 PyObject * obj0 = 0 ;
48374 PyObject * obj1 = 0 ;
48375 char * kwnames[] = {
48376 (char *) "self",(char *) "item", NULL
48377 };
48378
48379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48381 if (!SWIG_IsOK(res1)) {
48382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48383 }
48384 arg1 = reinterpret_cast< wxSizer * >(argp1);
48385 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48386 if (!SWIG_IsOK(res2)) {
48387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48388 }
48389 {
48390 PyThreadState* __tstate = wxPyBeginAllowThreads();
48391 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48392 wxPyEndAllowThreads(__tstate);
48393 if (PyErr_Occurred()) SWIG_fail;
48394 }
48395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48396 return resultobj;
48397 fail:
48398 return NULL;
48399 }
48400
48401
48402 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48403 PyObject *resultobj = 0;
48404 wxSizer *arg1 = (wxSizer *) 0 ;
48405 int arg2 ;
48406 int arg3 ;
48407 int arg4 ;
48408 int arg5 ;
48409 void *argp1 = 0 ;
48410 int res1 = 0 ;
48411 int val2 ;
48412 int ecode2 = 0 ;
48413 int val3 ;
48414 int ecode3 = 0 ;
48415 int val4 ;
48416 int ecode4 = 0 ;
48417 int val5 ;
48418 int ecode5 = 0 ;
48419 PyObject * obj0 = 0 ;
48420 PyObject * obj1 = 0 ;
48421 PyObject * obj2 = 0 ;
48422 PyObject * obj3 = 0 ;
48423 PyObject * obj4 = 0 ;
48424 char * kwnames[] = {
48425 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48426 };
48427
48428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48430 if (!SWIG_IsOK(res1)) {
48431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48432 }
48433 arg1 = reinterpret_cast< wxSizer * >(argp1);
48434 ecode2 = SWIG_AsVal_int(obj1, &val2);
48435 if (!SWIG_IsOK(ecode2)) {
48436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48437 }
48438 arg2 = static_cast< int >(val2);
48439 ecode3 = SWIG_AsVal_int(obj2, &val3);
48440 if (!SWIG_IsOK(ecode3)) {
48441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48442 }
48443 arg3 = static_cast< int >(val3);
48444 ecode4 = SWIG_AsVal_int(obj3, &val4);
48445 if (!SWIG_IsOK(ecode4)) {
48446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48447 }
48448 arg4 = static_cast< int >(val4);
48449 ecode5 = SWIG_AsVal_int(obj4, &val5);
48450 if (!SWIG_IsOK(ecode5)) {
48451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48452 }
48453 arg5 = static_cast< int >(val5);
48454 {
48455 PyThreadState* __tstate = wxPyBeginAllowThreads();
48456 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48457 wxPyEndAllowThreads(__tstate);
48458 if (PyErr_Occurred()) SWIG_fail;
48459 }
48460 resultobj = SWIG_Py_Void();
48461 return resultobj;
48462 fail:
48463 return NULL;
48464 }
48465
48466
48467 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48468 PyObject *resultobj = 0;
48469 wxSizer *arg1 = (wxSizer *) 0 ;
48470 wxSize *arg2 = 0 ;
48471 void *argp1 = 0 ;
48472 int res1 = 0 ;
48473 wxSize temp2 ;
48474 PyObject * obj0 = 0 ;
48475 PyObject * obj1 = 0 ;
48476 char * kwnames[] = {
48477 (char *) "self",(char *) "size", NULL
48478 };
48479
48480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48482 if (!SWIG_IsOK(res1)) {
48483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48484 }
48485 arg1 = reinterpret_cast< wxSizer * >(argp1);
48486 {
48487 arg2 = &temp2;
48488 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48489 }
48490 {
48491 PyThreadState* __tstate = wxPyBeginAllowThreads();
48492 (arg1)->SetMinSize((wxSize const &)*arg2);
48493 wxPyEndAllowThreads(__tstate);
48494 if (PyErr_Occurred()) SWIG_fail;
48495 }
48496 resultobj = SWIG_Py_Void();
48497 return resultobj;
48498 fail:
48499 return NULL;
48500 }
48501
48502
48503 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48504 PyObject *resultobj = 0;
48505 wxSizer *arg1 = (wxSizer *) 0 ;
48506 wxSize result;
48507 void *argp1 = 0 ;
48508 int res1 = 0 ;
48509 PyObject *swig_obj[1] ;
48510
48511 if (!args) SWIG_fail;
48512 swig_obj[0] = args;
48513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48514 if (!SWIG_IsOK(res1)) {
48515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48516 }
48517 arg1 = reinterpret_cast< wxSizer * >(argp1);
48518 {
48519 PyThreadState* __tstate = wxPyBeginAllowThreads();
48520 result = (arg1)->GetSize();
48521 wxPyEndAllowThreads(__tstate);
48522 if (PyErr_Occurred()) SWIG_fail;
48523 }
48524 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48525 return resultobj;
48526 fail:
48527 return NULL;
48528 }
48529
48530
48531 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48532 PyObject *resultobj = 0;
48533 wxSizer *arg1 = (wxSizer *) 0 ;
48534 wxPoint result;
48535 void *argp1 = 0 ;
48536 int res1 = 0 ;
48537 PyObject *swig_obj[1] ;
48538
48539 if (!args) SWIG_fail;
48540 swig_obj[0] = args;
48541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48542 if (!SWIG_IsOK(res1)) {
48543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48544 }
48545 arg1 = reinterpret_cast< wxSizer * >(argp1);
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 result = (arg1)->GetPosition();
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxSizer *arg1 = (wxSizer *) 0 ;
48562 wxSize result;
48563 void *argp1 = 0 ;
48564 int res1 = 0 ;
48565 PyObject *swig_obj[1] ;
48566
48567 if (!args) SWIG_fail;
48568 swig_obj[0] = args;
48569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48572 }
48573 arg1 = reinterpret_cast< wxSizer * >(argp1);
48574 {
48575 PyThreadState* __tstate = wxPyBeginAllowThreads();
48576 result = (arg1)->GetMinSize();
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48581 return resultobj;
48582 fail:
48583 return NULL;
48584 }
48585
48586
48587 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48588 PyObject *resultobj = 0;
48589 wxSizer *arg1 = (wxSizer *) 0 ;
48590 void *argp1 = 0 ;
48591 int res1 = 0 ;
48592 PyObject *swig_obj[1] ;
48593
48594 if (!args) SWIG_fail;
48595 swig_obj[0] = args;
48596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48597 if (!SWIG_IsOK(res1)) {
48598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48599 }
48600 arg1 = reinterpret_cast< wxSizer * >(argp1);
48601 {
48602 PyThreadState* __tstate = wxPyBeginAllowThreads();
48603 (arg1)->RecalcSizes();
48604 wxPyEndAllowThreads(__tstate);
48605 if (PyErr_Occurred()) SWIG_fail;
48606 }
48607 resultobj = SWIG_Py_Void();
48608 return resultobj;
48609 fail:
48610 return NULL;
48611 }
48612
48613
48614 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48615 PyObject *resultobj = 0;
48616 wxSizer *arg1 = (wxSizer *) 0 ;
48617 wxSize result;
48618 void *argp1 = 0 ;
48619 int res1 = 0 ;
48620 PyObject *swig_obj[1] ;
48621
48622 if (!args) SWIG_fail;
48623 swig_obj[0] = args;
48624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48625 if (!SWIG_IsOK(res1)) {
48626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48627 }
48628 arg1 = reinterpret_cast< wxSizer * >(argp1);
48629 {
48630 PyThreadState* __tstate = wxPyBeginAllowThreads();
48631 result = (arg1)->CalcMin();
48632 wxPyEndAllowThreads(__tstate);
48633 if (PyErr_Occurred()) SWIG_fail;
48634 }
48635 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48636 return resultobj;
48637 fail:
48638 return NULL;
48639 }
48640
48641
48642 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48643 PyObject *resultobj = 0;
48644 wxSizer *arg1 = (wxSizer *) 0 ;
48645 void *argp1 = 0 ;
48646 int res1 = 0 ;
48647 PyObject *swig_obj[1] ;
48648
48649 if (!args) SWIG_fail;
48650 swig_obj[0] = args;
48651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48652 if (!SWIG_IsOK(res1)) {
48653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48654 }
48655 arg1 = reinterpret_cast< wxSizer * >(argp1);
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 (arg1)->Layout();
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 resultobj = SWIG_Py_Void();
48663 return resultobj;
48664 fail:
48665 return NULL;
48666 }
48667
48668
48669 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48670 PyObject *resultobj = 0;
48671 wxSizer *arg1 = (wxSizer *) 0 ;
48672 wxWindow *arg2 = (wxWindow *) 0 ;
48673 wxSize result;
48674 void *argp1 = 0 ;
48675 int res1 = 0 ;
48676 void *argp2 = 0 ;
48677 int res2 = 0 ;
48678 PyObject * obj0 = 0 ;
48679 PyObject * obj1 = 0 ;
48680 char * kwnames[] = {
48681 (char *) "self",(char *) "window", NULL
48682 };
48683
48684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48686 if (!SWIG_IsOK(res1)) {
48687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48688 }
48689 arg1 = reinterpret_cast< wxSizer * >(argp1);
48690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48691 if (!SWIG_IsOK(res2)) {
48692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48693 }
48694 arg2 = reinterpret_cast< wxWindow * >(argp2);
48695 {
48696 PyThreadState* __tstate = wxPyBeginAllowThreads();
48697 result = (arg1)->Fit(arg2);
48698 wxPyEndAllowThreads(__tstate);
48699 if (PyErr_Occurred()) SWIG_fail;
48700 }
48701 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48702 return resultobj;
48703 fail:
48704 return NULL;
48705 }
48706
48707
48708 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48709 PyObject *resultobj = 0;
48710 wxSizer *arg1 = (wxSizer *) 0 ;
48711 wxWindow *arg2 = (wxWindow *) 0 ;
48712 void *argp1 = 0 ;
48713 int res1 = 0 ;
48714 void *argp2 = 0 ;
48715 int res2 = 0 ;
48716 PyObject * obj0 = 0 ;
48717 PyObject * obj1 = 0 ;
48718 char * kwnames[] = {
48719 (char *) "self",(char *) "window", NULL
48720 };
48721
48722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48724 if (!SWIG_IsOK(res1)) {
48725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48726 }
48727 arg1 = reinterpret_cast< wxSizer * >(argp1);
48728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48729 if (!SWIG_IsOK(res2)) {
48730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48731 }
48732 arg2 = reinterpret_cast< wxWindow * >(argp2);
48733 {
48734 PyThreadState* __tstate = wxPyBeginAllowThreads();
48735 (arg1)->FitInside(arg2);
48736 wxPyEndAllowThreads(__tstate);
48737 if (PyErr_Occurred()) SWIG_fail;
48738 }
48739 resultobj = SWIG_Py_Void();
48740 return resultobj;
48741 fail:
48742 return NULL;
48743 }
48744
48745
48746 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48747 PyObject *resultobj = 0;
48748 wxSizer *arg1 = (wxSizer *) 0 ;
48749 wxWindow *arg2 = (wxWindow *) 0 ;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 void *argp2 = 0 ;
48753 int res2 = 0 ;
48754 PyObject * obj0 = 0 ;
48755 PyObject * obj1 = 0 ;
48756 char * kwnames[] = {
48757 (char *) "self",(char *) "window", NULL
48758 };
48759
48760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48762 if (!SWIG_IsOK(res1)) {
48763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48764 }
48765 arg1 = reinterpret_cast< wxSizer * >(argp1);
48766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48767 if (!SWIG_IsOK(res2)) {
48768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48769 }
48770 arg2 = reinterpret_cast< wxWindow * >(argp2);
48771 {
48772 PyThreadState* __tstate = wxPyBeginAllowThreads();
48773 (arg1)->SetSizeHints(arg2);
48774 wxPyEndAllowThreads(__tstate);
48775 if (PyErr_Occurred()) SWIG_fail;
48776 }
48777 resultobj = SWIG_Py_Void();
48778 return resultobj;
48779 fail:
48780 return NULL;
48781 }
48782
48783
48784 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48785 PyObject *resultobj = 0;
48786 wxSizer *arg1 = (wxSizer *) 0 ;
48787 wxWindow *arg2 = (wxWindow *) 0 ;
48788 void *argp1 = 0 ;
48789 int res1 = 0 ;
48790 void *argp2 = 0 ;
48791 int res2 = 0 ;
48792 PyObject * obj0 = 0 ;
48793 PyObject * obj1 = 0 ;
48794 char * kwnames[] = {
48795 (char *) "self",(char *) "window", NULL
48796 };
48797
48798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48800 if (!SWIG_IsOK(res1)) {
48801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48802 }
48803 arg1 = reinterpret_cast< wxSizer * >(argp1);
48804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48805 if (!SWIG_IsOK(res2)) {
48806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48807 }
48808 arg2 = reinterpret_cast< wxWindow * >(argp2);
48809 {
48810 PyThreadState* __tstate = wxPyBeginAllowThreads();
48811 (arg1)->SetVirtualSizeHints(arg2);
48812 wxPyEndAllowThreads(__tstate);
48813 if (PyErr_Occurred()) SWIG_fail;
48814 }
48815 resultobj = SWIG_Py_Void();
48816 return resultobj;
48817 fail:
48818 return NULL;
48819 }
48820
48821
48822 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48823 PyObject *resultobj = 0;
48824 wxSizer *arg1 = (wxSizer *) 0 ;
48825 bool arg2 = (bool) false ;
48826 void *argp1 = 0 ;
48827 int res1 = 0 ;
48828 bool val2 ;
48829 int ecode2 = 0 ;
48830 PyObject * obj0 = 0 ;
48831 PyObject * obj1 = 0 ;
48832 char * kwnames[] = {
48833 (char *) "self",(char *) "deleteWindows", NULL
48834 };
48835
48836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48838 if (!SWIG_IsOK(res1)) {
48839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48840 }
48841 arg1 = reinterpret_cast< wxSizer * >(argp1);
48842 if (obj1) {
48843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48844 if (!SWIG_IsOK(ecode2)) {
48845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48846 }
48847 arg2 = static_cast< bool >(val2);
48848 }
48849 {
48850 PyThreadState* __tstate = wxPyBeginAllowThreads();
48851 (arg1)->Clear(arg2);
48852 wxPyEndAllowThreads(__tstate);
48853 if (PyErr_Occurred()) SWIG_fail;
48854 }
48855 resultobj = SWIG_Py_Void();
48856 return resultobj;
48857 fail:
48858 return NULL;
48859 }
48860
48861
48862 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48863 PyObject *resultobj = 0;
48864 wxSizer *arg1 = (wxSizer *) 0 ;
48865 void *argp1 = 0 ;
48866 int res1 = 0 ;
48867 PyObject *swig_obj[1] ;
48868
48869 if (!args) SWIG_fail;
48870 swig_obj[0] = args;
48871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48872 if (!SWIG_IsOK(res1)) {
48873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48874 }
48875 arg1 = reinterpret_cast< wxSizer * >(argp1);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 (arg1)->DeleteWindows();
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 resultobj = SWIG_Py_Void();
48883 return resultobj;
48884 fail:
48885 return NULL;
48886 }
48887
48888
48889 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48890 PyObject *resultobj = 0;
48891 wxSizer *arg1 = (wxSizer *) 0 ;
48892 PyObject *result = 0 ;
48893 void *argp1 = 0 ;
48894 int res1 = 0 ;
48895 PyObject *swig_obj[1] ;
48896
48897 if (!args) SWIG_fail;
48898 swig_obj[0] = args;
48899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48900 if (!SWIG_IsOK(res1)) {
48901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48902 }
48903 arg1 = reinterpret_cast< wxSizer * >(argp1);
48904 {
48905 PyThreadState* __tstate = wxPyBeginAllowThreads();
48906 result = (PyObject *)wxSizer_GetChildren(arg1);
48907 wxPyEndAllowThreads(__tstate);
48908 if (PyErr_Occurred()) SWIG_fail;
48909 }
48910 resultobj = result;
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48918 PyObject *resultobj = 0;
48919 wxSizer *arg1 = (wxSizer *) 0 ;
48920 PyObject *arg2 = (PyObject *) 0 ;
48921 bool arg3 = (bool) true ;
48922 bool arg4 = (bool) false ;
48923 bool result;
48924 void *argp1 = 0 ;
48925 int res1 = 0 ;
48926 bool val3 ;
48927 int ecode3 = 0 ;
48928 bool val4 ;
48929 int ecode4 = 0 ;
48930 PyObject * obj0 = 0 ;
48931 PyObject * obj1 = 0 ;
48932 PyObject * obj2 = 0 ;
48933 PyObject * obj3 = 0 ;
48934 char * kwnames[] = {
48935 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48936 };
48937
48938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48940 if (!SWIG_IsOK(res1)) {
48941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48942 }
48943 arg1 = reinterpret_cast< wxSizer * >(argp1);
48944 arg2 = obj1;
48945 if (obj2) {
48946 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48947 if (!SWIG_IsOK(ecode3)) {
48948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48949 }
48950 arg3 = static_cast< bool >(val3);
48951 }
48952 if (obj3) {
48953 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48954 if (!SWIG_IsOK(ecode4)) {
48955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48956 }
48957 arg4 = static_cast< bool >(val4);
48958 }
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48962 wxPyEndAllowThreads(__tstate);
48963 if (PyErr_Occurred()) SWIG_fail;
48964 }
48965 {
48966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48967 }
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48975 PyObject *resultobj = 0;
48976 wxSizer *arg1 = (wxSizer *) 0 ;
48977 PyObject *arg2 = (PyObject *) 0 ;
48978 bool result;
48979 void *argp1 = 0 ;
48980 int res1 = 0 ;
48981 PyObject * obj0 = 0 ;
48982 PyObject * obj1 = 0 ;
48983 char * kwnames[] = {
48984 (char *) "self",(char *) "item", NULL
48985 };
48986
48987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48991 }
48992 arg1 = reinterpret_cast< wxSizer * >(argp1);
48993 arg2 = obj1;
48994 {
48995 PyThreadState* __tstate = wxPyBeginAllowThreads();
48996 result = (bool)wxSizer_IsShown(arg1,arg2);
48997 wxPyEndAllowThreads(__tstate);
48998 if (PyErr_Occurred()) SWIG_fail;
48999 }
49000 {
49001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49002 }
49003 return resultobj;
49004 fail:
49005 return NULL;
49006 }
49007
49008
49009 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49010 PyObject *resultobj = 0;
49011 wxSizer *arg1 = (wxSizer *) 0 ;
49012 bool arg2 ;
49013 void *argp1 = 0 ;
49014 int res1 = 0 ;
49015 bool val2 ;
49016 int ecode2 = 0 ;
49017 PyObject * obj0 = 0 ;
49018 PyObject * obj1 = 0 ;
49019 char * kwnames[] = {
49020 (char *) "self",(char *) "show", NULL
49021 };
49022
49023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
49024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49025 if (!SWIG_IsOK(res1)) {
49026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
49027 }
49028 arg1 = reinterpret_cast< wxSizer * >(argp1);
49029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49030 if (!SWIG_IsOK(ecode2)) {
49031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49032 }
49033 arg2 = static_cast< bool >(val2);
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 (arg1)->ShowItems(arg2);
49037 wxPyEndAllowThreads(__tstate);
49038 if (PyErr_Occurred()) SWIG_fail;
49039 }
49040 resultobj = SWIG_Py_Void();
49041 return resultobj;
49042 fail:
49043 return NULL;
49044 }
49045
49046
49047 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49048 PyObject *obj;
49049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49050 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49051 return SWIG_Py_Void();
49052 }
49053
49054 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49055 PyObject *resultobj = 0;
49056 wxPySizer *result = 0 ;
49057
49058 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49059 {
49060 PyThreadState* __tstate = wxPyBeginAllowThreads();
49061 result = (wxPySizer *)new wxPySizer();
49062 wxPyEndAllowThreads(__tstate);
49063 if (PyErr_Occurred()) SWIG_fail;
49064 }
49065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49066 return resultobj;
49067 fail:
49068 return NULL;
49069 }
49070
49071
49072 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49073 PyObject *resultobj = 0;
49074 wxPySizer *arg1 = (wxPySizer *) 0 ;
49075 PyObject *arg2 = (PyObject *) 0 ;
49076 PyObject *arg3 = (PyObject *) 0 ;
49077 void *argp1 = 0 ;
49078 int res1 = 0 ;
49079 PyObject * obj0 = 0 ;
49080 PyObject * obj1 = 0 ;
49081 PyObject * obj2 = 0 ;
49082 char * kwnames[] = {
49083 (char *) "self",(char *) "self",(char *) "_class", NULL
49084 };
49085
49086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49088 if (!SWIG_IsOK(res1)) {
49089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49090 }
49091 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49092 arg2 = obj1;
49093 arg3 = obj2;
49094 {
49095 PyThreadState* __tstate = wxPyBeginAllowThreads();
49096 (arg1)->_setCallbackInfo(arg2,arg3);
49097 wxPyEndAllowThreads(__tstate);
49098 if (PyErr_Occurred()) SWIG_fail;
49099 }
49100 resultobj = SWIG_Py_Void();
49101 return resultobj;
49102 fail:
49103 return NULL;
49104 }
49105
49106
49107 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49108 PyObject *obj;
49109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49110 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49111 return SWIG_Py_Void();
49112 }
49113
49114 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49115 return SWIG_Python_InitShadowInstance(args);
49116 }
49117
49118 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49119 PyObject *resultobj = 0;
49120 int arg1 = (int) wxHORIZONTAL ;
49121 wxBoxSizer *result = 0 ;
49122 int val1 ;
49123 int ecode1 = 0 ;
49124 PyObject * obj0 = 0 ;
49125 char * kwnames[] = {
49126 (char *) "orient", NULL
49127 };
49128
49129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49130 if (obj0) {
49131 ecode1 = SWIG_AsVal_int(obj0, &val1);
49132 if (!SWIG_IsOK(ecode1)) {
49133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49134 }
49135 arg1 = static_cast< int >(val1);
49136 }
49137 {
49138 PyThreadState* __tstate = wxPyBeginAllowThreads();
49139 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49140 wxPyEndAllowThreads(__tstate);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49144 return resultobj;
49145 fail:
49146 return NULL;
49147 }
49148
49149
49150 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49151 PyObject *resultobj = 0;
49152 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49153 int result;
49154 void *argp1 = 0 ;
49155 int res1 = 0 ;
49156 PyObject *swig_obj[1] ;
49157
49158 if (!args) SWIG_fail;
49159 swig_obj[0] = args;
49160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49161 if (!SWIG_IsOK(res1)) {
49162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49163 }
49164 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49165 {
49166 PyThreadState* __tstate = wxPyBeginAllowThreads();
49167 result = (int)(arg1)->GetOrientation();
49168 wxPyEndAllowThreads(__tstate);
49169 if (PyErr_Occurred()) SWIG_fail;
49170 }
49171 resultobj = SWIG_From_int(static_cast< int >(result));
49172 return resultobj;
49173 fail:
49174 return NULL;
49175 }
49176
49177
49178 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49179 PyObject *resultobj = 0;
49180 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49181 int arg2 ;
49182 void *argp1 = 0 ;
49183 int res1 = 0 ;
49184 int val2 ;
49185 int ecode2 = 0 ;
49186 PyObject * obj0 = 0 ;
49187 PyObject * obj1 = 0 ;
49188 char * kwnames[] = {
49189 (char *) "self",(char *) "orient", NULL
49190 };
49191
49192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49194 if (!SWIG_IsOK(res1)) {
49195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49196 }
49197 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49198 ecode2 = SWIG_AsVal_int(obj1, &val2);
49199 if (!SWIG_IsOK(ecode2)) {
49200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49201 }
49202 arg2 = static_cast< int >(val2);
49203 {
49204 PyThreadState* __tstate = wxPyBeginAllowThreads();
49205 (arg1)->SetOrientation(arg2);
49206 wxPyEndAllowThreads(__tstate);
49207 if (PyErr_Occurred()) SWIG_fail;
49208 }
49209 resultobj = SWIG_Py_Void();
49210 return resultobj;
49211 fail:
49212 return NULL;
49213 }
49214
49215
49216 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49217 PyObject *obj;
49218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49219 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49220 return SWIG_Py_Void();
49221 }
49222
49223 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49224 return SWIG_Python_InitShadowInstance(args);
49225 }
49226
49227 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49228 PyObject *resultobj = 0;
49229 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49230 int arg2 = (int) wxHORIZONTAL ;
49231 wxStaticBoxSizer *result = 0 ;
49232 void *argp1 = 0 ;
49233 int res1 = 0 ;
49234 int val2 ;
49235 int ecode2 = 0 ;
49236 PyObject * obj0 = 0 ;
49237 PyObject * obj1 = 0 ;
49238 char * kwnames[] = {
49239 (char *) "box",(char *) "orient", NULL
49240 };
49241
49242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49244 if (!SWIG_IsOK(res1)) {
49245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49246 }
49247 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49248 if (obj1) {
49249 ecode2 = SWIG_AsVal_int(obj1, &val2);
49250 if (!SWIG_IsOK(ecode2)) {
49251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49252 }
49253 arg2 = static_cast< int >(val2);
49254 }
49255 {
49256 PyThreadState* __tstate = wxPyBeginAllowThreads();
49257 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49258 wxPyEndAllowThreads(__tstate);
49259 if (PyErr_Occurred()) SWIG_fail;
49260 }
49261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49262 return resultobj;
49263 fail:
49264 return NULL;
49265 }
49266
49267
49268 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49269 PyObject *resultobj = 0;
49270 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49271 wxStaticBox *result = 0 ;
49272 void *argp1 = 0 ;
49273 int res1 = 0 ;
49274 PyObject *swig_obj[1] ;
49275
49276 if (!args) SWIG_fail;
49277 swig_obj[0] = args;
49278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49279 if (!SWIG_IsOK(res1)) {
49280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49281 }
49282 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49283 {
49284 PyThreadState* __tstate = wxPyBeginAllowThreads();
49285 result = (wxStaticBox *)(arg1)->GetStaticBox();
49286 wxPyEndAllowThreads(__tstate);
49287 if (PyErr_Occurred()) SWIG_fail;
49288 }
49289 {
49290 resultobj = wxPyMake_wxObject(result, (bool)0);
49291 }
49292 return resultobj;
49293 fail:
49294 return NULL;
49295 }
49296
49297
49298 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49299 PyObject *obj;
49300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49301 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49302 return SWIG_Py_Void();
49303 }
49304
49305 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49306 return SWIG_Python_InitShadowInstance(args);
49307 }
49308
49309 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49310 PyObject *resultobj = 0;
49311 int arg1 = (int) 1 ;
49312 int arg2 = (int) 0 ;
49313 int arg3 = (int) 0 ;
49314 int arg4 = (int) 0 ;
49315 wxGridSizer *result = 0 ;
49316 int val1 ;
49317 int ecode1 = 0 ;
49318 int val2 ;
49319 int ecode2 = 0 ;
49320 int val3 ;
49321 int ecode3 = 0 ;
49322 int val4 ;
49323 int ecode4 = 0 ;
49324 PyObject * obj0 = 0 ;
49325 PyObject * obj1 = 0 ;
49326 PyObject * obj2 = 0 ;
49327 PyObject * obj3 = 0 ;
49328 char * kwnames[] = {
49329 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49330 };
49331
49332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49333 if (obj0) {
49334 ecode1 = SWIG_AsVal_int(obj0, &val1);
49335 if (!SWIG_IsOK(ecode1)) {
49336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49337 }
49338 arg1 = static_cast< int >(val1);
49339 }
49340 if (obj1) {
49341 ecode2 = SWIG_AsVal_int(obj1, &val2);
49342 if (!SWIG_IsOK(ecode2)) {
49343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49344 }
49345 arg2 = static_cast< int >(val2);
49346 }
49347 if (obj2) {
49348 ecode3 = SWIG_AsVal_int(obj2, &val3);
49349 if (!SWIG_IsOK(ecode3)) {
49350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49351 }
49352 arg3 = static_cast< int >(val3);
49353 }
49354 if (obj3) {
49355 ecode4 = SWIG_AsVal_int(obj3, &val4);
49356 if (!SWIG_IsOK(ecode4)) {
49357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49358 }
49359 arg4 = static_cast< int >(val4);
49360 }
49361 {
49362 PyThreadState* __tstate = wxPyBeginAllowThreads();
49363 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49364 wxPyEndAllowThreads(__tstate);
49365 if (PyErr_Occurred()) SWIG_fail;
49366 }
49367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49368 return resultobj;
49369 fail:
49370 return NULL;
49371 }
49372
49373
49374 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49375 PyObject *resultobj = 0;
49376 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49377 int arg2 ;
49378 void *argp1 = 0 ;
49379 int res1 = 0 ;
49380 int val2 ;
49381 int ecode2 = 0 ;
49382 PyObject * obj0 = 0 ;
49383 PyObject * obj1 = 0 ;
49384 char * kwnames[] = {
49385 (char *) "self",(char *) "cols", NULL
49386 };
49387
49388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49390 if (!SWIG_IsOK(res1)) {
49391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49392 }
49393 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49394 ecode2 = SWIG_AsVal_int(obj1, &val2);
49395 if (!SWIG_IsOK(ecode2)) {
49396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49397 }
49398 arg2 = static_cast< int >(val2);
49399 {
49400 PyThreadState* __tstate = wxPyBeginAllowThreads();
49401 (arg1)->SetCols(arg2);
49402 wxPyEndAllowThreads(__tstate);
49403 if (PyErr_Occurred()) SWIG_fail;
49404 }
49405 resultobj = SWIG_Py_Void();
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49413 PyObject *resultobj = 0;
49414 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49415 int arg2 ;
49416 void *argp1 = 0 ;
49417 int res1 = 0 ;
49418 int val2 ;
49419 int ecode2 = 0 ;
49420 PyObject * obj0 = 0 ;
49421 PyObject * obj1 = 0 ;
49422 char * kwnames[] = {
49423 (char *) "self",(char *) "rows", NULL
49424 };
49425
49426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49428 if (!SWIG_IsOK(res1)) {
49429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49430 }
49431 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49432 ecode2 = SWIG_AsVal_int(obj1, &val2);
49433 if (!SWIG_IsOK(ecode2)) {
49434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49435 }
49436 arg2 = static_cast< int >(val2);
49437 {
49438 PyThreadState* __tstate = wxPyBeginAllowThreads();
49439 (arg1)->SetRows(arg2);
49440 wxPyEndAllowThreads(__tstate);
49441 if (PyErr_Occurred()) SWIG_fail;
49442 }
49443 resultobj = SWIG_Py_Void();
49444 return resultobj;
49445 fail:
49446 return NULL;
49447 }
49448
49449
49450 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49451 PyObject *resultobj = 0;
49452 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49453 int arg2 ;
49454 void *argp1 = 0 ;
49455 int res1 = 0 ;
49456 int val2 ;
49457 int ecode2 = 0 ;
49458 PyObject * obj0 = 0 ;
49459 PyObject * obj1 = 0 ;
49460 char * kwnames[] = {
49461 (char *) "self",(char *) "gap", NULL
49462 };
49463
49464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49466 if (!SWIG_IsOK(res1)) {
49467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49468 }
49469 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49470 ecode2 = SWIG_AsVal_int(obj1, &val2);
49471 if (!SWIG_IsOK(ecode2)) {
49472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49473 }
49474 arg2 = static_cast< int >(val2);
49475 {
49476 PyThreadState* __tstate = wxPyBeginAllowThreads();
49477 (arg1)->SetVGap(arg2);
49478 wxPyEndAllowThreads(__tstate);
49479 if (PyErr_Occurred()) SWIG_fail;
49480 }
49481 resultobj = SWIG_Py_Void();
49482 return resultobj;
49483 fail:
49484 return NULL;
49485 }
49486
49487
49488 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49489 PyObject *resultobj = 0;
49490 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49491 int arg2 ;
49492 void *argp1 = 0 ;
49493 int res1 = 0 ;
49494 int val2 ;
49495 int ecode2 = 0 ;
49496 PyObject * obj0 = 0 ;
49497 PyObject * obj1 = 0 ;
49498 char * kwnames[] = {
49499 (char *) "self",(char *) "gap", NULL
49500 };
49501
49502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49504 if (!SWIG_IsOK(res1)) {
49505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49506 }
49507 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49508 ecode2 = SWIG_AsVal_int(obj1, &val2);
49509 if (!SWIG_IsOK(ecode2)) {
49510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49511 }
49512 arg2 = static_cast< int >(val2);
49513 {
49514 PyThreadState* __tstate = wxPyBeginAllowThreads();
49515 (arg1)->SetHGap(arg2);
49516 wxPyEndAllowThreads(__tstate);
49517 if (PyErr_Occurred()) SWIG_fail;
49518 }
49519 resultobj = SWIG_Py_Void();
49520 return resultobj;
49521 fail:
49522 return NULL;
49523 }
49524
49525
49526 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49527 PyObject *resultobj = 0;
49528 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49529 int result;
49530 void *argp1 = 0 ;
49531 int res1 = 0 ;
49532 PyObject *swig_obj[1] ;
49533
49534 if (!args) SWIG_fail;
49535 swig_obj[0] = args;
49536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49537 if (!SWIG_IsOK(res1)) {
49538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49539 }
49540 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 result = (int)(arg1)->GetCols();
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 resultobj = SWIG_From_int(static_cast< int >(result));
49548 return resultobj;
49549 fail:
49550 return NULL;
49551 }
49552
49553
49554 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49555 PyObject *resultobj = 0;
49556 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49557 int result;
49558 void *argp1 = 0 ;
49559 int res1 = 0 ;
49560 PyObject *swig_obj[1] ;
49561
49562 if (!args) SWIG_fail;
49563 swig_obj[0] = args;
49564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49565 if (!SWIG_IsOK(res1)) {
49566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49567 }
49568 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49569 {
49570 PyThreadState* __tstate = wxPyBeginAllowThreads();
49571 result = (int)(arg1)->GetRows();
49572 wxPyEndAllowThreads(__tstate);
49573 if (PyErr_Occurred()) SWIG_fail;
49574 }
49575 resultobj = SWIG_From_int(static_cast< int >(result));
49576 return resultobj;
49577 fail:
49578 return NULL;
49579 }
49580
49581
49582 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49583 PyObject *resultobj = 0;
49584 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49585 int result;
49586 void *argp1 = 0 ;
49587 int res1 = 0 ;
49588 PyObject *swig_obj[1] ;
49589
49590 if (!args) SWIG_fail;
49591 swig_obj[0] = args;
49592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49593 if (!SWIG_IsOK(res1)) {
49594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49595 }
49596 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49597 {
49598 PyThreadState* __tstate = wxPyBeginAllowThreads();
49599 result = (int)(arg1)->GetVGap();
49600 wxPyEndAllowThreads(__tstate);
49601 if (PyErr_Occurred()) SWIG_fail;
49602 }
49603 resultobj = SWIG_From_int(static_cast< int >(result));
49604 return resultobj;
49605 fail:
49606 return NULL;
49607 }
49608
49609
49610 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49611 PyObject *resultobj = 0;
49612 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49613 int result;
49614 void *argp1 = 0 ;
49615 int res1 = 0 ;
49616 PyObject *swig_obj[1] ;
49617
49618 if (!args) SWIG_fail;
49619 swig_obj[0] = args;
49620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49621 if (!SWIG_IsOK(res1)) {
49622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49623 }
49624 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49625 {
49626 PyThreadState* __tstate = wxPyBeginAllowThreads();
49627 result = (int)(arg1)->GetHGap();
49628 wxPyEndAllowThreads(__tstate);
49629 if (PyErr_Occurred()) SWIG_fail;
49630 }
49631 resultobj = SWIG_From_int(static_cast< int >(result));
49632 return resultobj;
49633 fail:
49634 return NULL;
49635 }
49636
49637
49638 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49639 PyObject *obj;
49640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49641 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49642 return SWIG_Py_Void();
49643 }
49644
49645 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49646 return SWIG_Python_InitShadowInstance(args);
49647 }
49648
49649 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49650 PyObject *resultobj = 0;
49651 int arg1 = (int) 1 ;
49652 int arg2 = (int) 0 ;
49653 int arg3 = (int) 0 ;
49654 int arg4 = (int) 0 ;
49655 wxFlexGridSizer *result = 0 ;
49656 int val1 ;
49657 int ecode1 = 0 ;
49658 int val2 ;
49659 int ecode2 = 0 ;
49660 int val3 ;
49661 int ecode3 = 0 ;
49662 int val4 ;
49663 int ecode4 = 0 ;
49664 PyObject * obj0 = 0 ;
49665 PyObject * obj1 = 0 ;
49666 PyObject * obj2 = 0 ;
49667 PyObject * obj3 = 0 ;
49668 char * kwnames[] = {
49669 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49670 };
49671
49672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49673 if (obj0) {
49674 ecode1 = SWIG_AsVal_int(obj0, &val1);
49675 if (!SWIG_IsOK(ecode1)) {
49676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49677 }
49678 arg1 = static_cast< int >(val1);
49679 }
49680 if (obj1) {
49681 ecode2 = SWIG_AsVal_int(obj1, &val2);
49682 if (!SWIG_IsOK(ecode2)) {
49683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49684 }
49685 arg2 = static_cast< int >(val2);
49686 }
49687 if (obj2) {
49688 ecode3 = SWIG_AsVal_int(obj2, &val3);
49689 if (!SWIG_IsOK(ecode3)) {
49690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49691 }
49692 arg3 = static_cast< int >(val3);
49693 }
49694 if (obj3) {
49695 ecode4 = SWIG_AsVal_int(obj3, &val4);
49696 if (!SWIG_IsOK(ecode4)) {
49697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49698 }
49699 arg4 = static_cast< int >(val4);
49700 }
49701 {
49702 PyThreadState* __tstate = wxPyBeginAllowThreads();
49703 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49704 wxPyEndAllowThreads(__tstate);
49705 if (PyErr_Occurred()) SWIG_fail;
49706 }
49707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49708 return resultobj;
49709 fail:
49710 return NULL;
49711 }
49712
49713
49714 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49715 PyObject *resultobj = 0;
49716 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49717 size_t arg2 ;
49718 int arg3 = (int) 0 ;
49719 void *argp1 = 0 ;
49720 int res1 = 0 ;
49721 size_t val2 ;
49722 int ecode2 = 0 ;
49723 int val3 ;
49724 int ecode3 = 0 ;
49725 PyObject * obj0 = 0 ;
49726 PyObject * obj1 = 0 ;
49727 PyObject * obj2 = 0 ;
49728 char * kwnames[] = {
49729 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49730 };
49731
49732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49734 if (!SWIG_IsOK(res1)) {
49735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49736 }
49737 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49738 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49739 if (!SWIG_IsOK(ecode2)) {
49740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49741 }
49742 arg2 = static_cast< size_t >(val2);
49743 if (obj2) {
49744 ecode3 = SWIG_AsVal_int(obj2, &val3);
49745 if (!SWIG_IsOK(ecode3)) {
49746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49747 }
49748 arg3 = static_cast< int >(val3);
49749 }
49750 {
49751 PyThreadState* __tstate = wxPyBeginAllowThreads();
49752 (arg1)->AddGrowableRow(arg2,arg3);
49753 wxPyEndAllowThreads(__tstate);
49754 if (PyErr_Occurred()) SWIG_fail;
49755 }
49756 resultobj = SWIG_Py_Void();
49757 return resultobj;
49758 fail:
49759 return NULL;
49760 }
49761
49762
49763 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49764 PyObject *resultobj = 0;
49765 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49766 size_t arg2 ;
49767 void *argp1 = 0 ;
49768 int res1 = 0 ;
49769 size_t val2 ;
49770 int ecode2 = 0 ;
49771 PyObject * obj0 = 0 ;
49772 PyObject * obj1 = 0 ;
49773 char * kwnames[] = {
49774 (char *) "self",(char *) "idx", NULL
49775 };
49776
49777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49779 if (!SWIG_IsOK(res1)) {
49780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49781 }
49782 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49783 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49784 if (!SWIG_IsOK(ecode2)) {
49785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49786 }
49787 arg2 = static_cast< size_t >(val2);
49788 {
49789 PyThreadState* __tstate = wxPyBeginAllowThreads();
49790 (arg1)->RemoveGrowableRow(arg2);
49791 wxPyEndAllowThreads(__tstate);
49792 if (PyErr_Occurred()) SWIG_fail;
49793 }
49794 resultobj = SWIG_Py_Void();
49795 return resultobj;
49796 fail:
49797 return NULL;
49798 }
49799
49800
49801 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49802 PyObject *resultobj = 0;
49803 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49804 size_t arg2 ;
49805 int arg3 = (int) 0 ;
49806 void *argp1 = 0 ;
49807 int res1 = 0 ;
49808 size_t val2 ;
49809 int ecode2 = 0 ;
49810 int val3 ;
49811 int ecode3 = 0 ;
49812 PyObject * obj0 = 0 ;
49813 PyObject * obj1 = 0 ;
49814 PyObject * obj2 = 0 ;
49815 char * kwnames[] = {
49816 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49817 };
49818
49819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49821 if (!SWIG_IsOK(res1)) {
49822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49823 }
49824 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49825 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49826 if (!SWIG_IsOK(ecode2)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49828 }
49829 arg2 = static_cast< size_t >(val2);
49830 if (obj2) {
49831 ecode3 = SWIG_AsVal_int(obj2, &val3);
49832 if (!SWIG_IsOK(ecode3)) {
49833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49834 }
49835 arg3 = static_cast< int >(val3);
49836 }
49837 {
49838 PyThreadState* __tstate = wxPyBeginAllowThreads();
49839 (arg1)->AddGrowableCol(arg2,arg3);
49840 wxPyEndAllowThreads(__tstate);
49841 if (PyErr_Occurred()) SWIG_fail;
49842 }
49843 resultobj = SWIG_Py_Void();
49844 return resultobj;
49845 fail:
49846 return NULL;
49847 }
49848
49849
49850 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49851 PyObject *resultobj = 0;
49852 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49853 size_t arg2 ;
49854 void *argp1 = 0 ;
49855 int res1 = 0 ;
49856 size_t val2 ;
49857 int ecode2 = 0 ;
49858 PyObject * obj0 = 0 ;
49859 PyObject * obj1 = 0 ;
49860 char * kwnames[] = {
49861 (char *) "self",(char *) "idx", NULL
49862 };
49863
49864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49866 if (!SWIG_IsOK(res1)) {
49867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49868 }
49869 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49870 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49871 if (!SWIG_IsOK(ecode2)) {
49872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49873 }
49874 arg2 = static_cast< size_t >(val2);
49875 {
49876 PyThreadState* __tstate = wxPyBeginAllowThreads();
49877 (arg1)->RemoveGrowableCol(arg2);
49878 wxPyEndAllowThreads(__tstate);
49879 if (PyErr_Occurred()) SWIG_fail;
49880 }
49881 resultobj = SWIG_Py_Void();
49882 return resultobj;
49883 fail:
49884 return NULL;
49885 }
49886
49887
49888 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49889 PyObject *resultobj = 0;
49890 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49891 int arg2 ;
49892 void *argp1 = 0 ;
49893 int res1 = 0 ;
49894 int val2 ;
49895 int ecode2 = 0 ;
49896 PyObject * obj0 = 0 ;
49897 PyObject * obj1 = 0 ;
49898 char * kwnames[] = {
49899 (char *) "self",(char *) "direction", NULL
49900 };
49901
49902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49904 if (!SWIG_IsOK(res1)) {
49905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49906 }
49907 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49908 ecode2 = SWIG_AsVal_int(obj1, &val2);
49909 if (!SWIG_IsOK(ecode2)) {
49910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49911 }
49912 arg2 = static_cast< int >(val2);
49913 {
49914 PyThreadState* __tstate = wxPyBeginAllowThreads();
49915 (arg1)->SetFlexibleDirection(arg2);
49916 wxPyEndAllowThreads(__tstate);
49917 if (PyErr_Occurred()) SWIG_fail;
49918 }
49919 resultobj = SWIG_Py_Void();
49920 return resultobj;
49921 fail:
49922 return NULL;
49923 }
49924
49925
49926 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49927 PyObject *resultobj = 0;
49928 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49929 int result;
49930 void *argp1 = 0 ;
49931 int res1 = 0 ;
49932 PyObject *swig_obj[1] ;
49933
49934 if (!args) SWIG_fail;
49935 swig_obj[0] = args;
49936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49937 if (!SWIG_IsOK(res1)) {
49938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49939 }
49940 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49941 {
49942 PyThreadState* __tstate = wxPyBeginAllowThreads();
49943 result = (int)(arg1)->GetFlexibleDirection();
49944 wxPyEndAllowThreads(__tstate);
49945 if (PyErr_Occurred()) SWIG_fail;
49946 }
49947 resultobj = SWIG_From_int(static_cast< int >(result));
49948 return resultobj;
49949 fail:
49950 return NULL;
49951 }
49952
49953
49954 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49955 PyObject *resultobj = 0;
49956 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49957 wxFlexSizerGrowMode arg2 ;
49958 void *argp1 = 0 ;
49959 int res1 = 0 ;
49960 int val2 ;
49961 int ecode2 = 0 ;
49962 PyObject * obj0 = 0 ;
49963 PyObject * obj1 = 0 ;
49964 char * kwnames[] = {
49965 (char *) "self",(char *) "mode", NULL
49966 };
49967
49968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49970 if (!SWIG_IsOK(res1)) {
49971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49972 }
49973 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49974 ecode2 = SWIG_AsVal_int(obj1, &val2);
49975 if (!SWIG_IsOK(ecode2)) {
49976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49977 }
49978 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49979 {
49980 PyThreadState* __tstate = wxPyBeginAllowThreads();
49981 (arg1)->SetNonFlexibleGrowMode(arg2);
49982 wxPyEndAllowThreads(__tstate);
49983 if (PyErr_Occurred()) SWIG_fail;
49984 }
49985 resultobj = SWIG_Py_Void();
49986 return resultobj;
49987 fail:
49988 return NULL;
49989 }
49990
49991
49992 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49993 PyObject *resultobj = 0;
49994 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49995 wxFlexSizerGrowMode result;
49996 void *argp1 = 0 ;
49997 int res1 = 0 ;
49998 PyObject *swig_obj[1] ;
49999
50000 if (!args) SWIG_fail;
50001 swig_obj[0] = args;
50002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50003 if (!SWIG_IsOK(res1)) {
50004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
50005 }
50006 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 resultobj = SWIG_From_int(static_cast< int >(result));
50014 return resultobj;
50015 fail:
50016 return NULL;
50017 }
50018
50019
50020 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50021 PyObject *resultobj = 0;
50022 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50023 wxArrayInt *result = 0 ;
50024 void *argp1 = 0 ;
50025 int res1 = 0 ;
50026 PyObject *swig_obj[1] ;
50027
50028 if (!args) SWIG_fail;
50029 swig_obj[0] = args;
50030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50031 if (!SWIG_IsOK(res1)) {
50032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50033 }
50034 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50035 {
50036 PyThreadState* __tstate = wxPyBeginAllowThreads();
50037 {
50038 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50039 result = (wxArrayInt *) &_result_ref;
50040 }
50041 wxPyEndAllowThreads(__tstate);
50042 if (PyErr_Occurred()) SWIG_fail;
50043 }
50044 {
50045 resultobj = wxArrayInt2PyList_helper(*result);
50046 }
50047 return resultobj;
50048 fail:
50049 return NULL;
50050 }
50051
50052
50053 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50054 PyObject *resultobj = 0;
50055 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50056 wxArrayInt *result = 0 ;
50057 void *argp1 = 0 ;
50058 int res1 = 0 ;
50059 PyObject *swig_obj[1] ;
50060
50061 if (!args) SWIG_fail;
50062 swig_obj[0] = args;
50063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50064 if (!SWIG_IsOK(res1)) {
50065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50066 }
50067 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50068 {
50069 PyThreadState* __tstate = wxPyBeginAllowThreads();
50070 {
50071 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50072 result = (wxArrayInt *) &_result_ref;
50073 }
50074 wxPyEndAllowThreads(__tstate);
50075 if (PyErr_Occurred()) SWIG_fail;
50076 }
50077 {
50078 resultobj = wxArrayInt2PyList_helper(*result);
50079 }
50080 return resultobj;
50081 fail:
50082 return NULL;
50083 }
50084
50085
50086 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50087 PyObject *obj;
50088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50089 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50090 return SWIG_Py_Void();
50091 }
50092
50093 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50094 return SWIG_Python_InitShadowInstance(args);
50095 }
50096
50097 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50098 PyObject *resultobj = 0;
50099 wxStdDialogButtonSizer *result = 0 ;
50100
50101 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50102 {
50103 PyThreadState* __tstate = wxPyBeginAllowThreads();
50104 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50105 wxPyEndAllowThreads(__tstate);
50106 if (PyErr_Occurred()) SWIG_fail;
50107 }
50108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50109 return resultobj;
50110 fail:
50111 return NULL;
50112 }
50113
50114
50115 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50116 PyObject *resultobj = 0;
50117 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50118 wxButton *arg2 = (wxButton *) 0 ;
50119 void *argp1 = 0 ;
50120 int res1 = 0 ;
50121 void *argp2 = 0 ;
50122 int res2 = 0 ;
50123 PyObject * obj0 = 0 ;
50124 PyObject * obj1 = 0 ;
50125 char * kwnames[] = {
50126 (char *) "self",(char *) "button", NULL
50127 };
50128
50129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50131 if (!SWIG_IsOK(res1)) {
50132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50133 }
50134 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50136 if (!SWIG_IsOK(res2)) {
50137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50138 }
50139 arg2 = reinterpret_cast< wxButton * >(argp2);
50140 {
50141 PyThreadState* __tstate = wxPyBeginAllowThreads();
50142 (arg1)->AddButton(arg2);
50143 wxPyEndAllowThreads(__tstate);
50144 if (PyErr_Occurred()) SWIG_fail;
50145 }
50146 resultobj = SWIG_Py_Void();
50147 return resultobj;
50148 fail:
50149 return NULL;
50150 }
50151
50152
50153 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50154 PyObject *resultobj = 0;
50155 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50156 void *argp1 = 0 ;
50157 int res1 = 0 ;
50158 PyObject *swig_obj[1] ;
50159
50160 if (!args) SWIG_fail;
50161 swig_obj[0] = args;
50162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50163 if (!SWIG_IsOK(res1)) {
50164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50165 }
50166 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50167 {
50168 PyThreadState* __tstate = wxPyBeginAllowThreads();
50169 (arg1)->Realize();
50170 wxPyEndAllowThreads(__tstate);
50171 if (PyErr_Occurred()) SWIG_fail;
50172 }
50173 resultobj = SWIG_Py_Void();
50174 return resultobj;
50175 fail:
50176 return NULL;
50177 }
50178
50179
50180 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50181 PyObject *resultobj = 0;
50182 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50183 wxButton *arg2 = (wxButton *) 0 ;
50184 void *argp1 = 0 ;
50185 int res1 = 0 ;
50186 void *argp2 = 0 ;
50187 int res2 = 0 ;
50188 PyObject * obj0 = 0 ;
50189 PyObject * obj1 = 0 ;
50190 char * kwnames[] = {
50191 (char *) "self",(char *) "button", NULL
50192 };
50193
50194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50196 if (!SWIG_IsOK(res1)) {
50197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50198 }
50199 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50201 if (!SWIG_IsOK(res2)) {
50202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50203 }
50204 arg2 = reinterpret_cast< wxButton * >(argp2);
50205 {
50206 PyThreadState* __tstate = wxPyBeginAllowThreads();
50207 (arg1)->SetAffirmativeButton(arg2);
50208 wxPyEndAllowThreads(__tstate);
50209 if (PyErr_Occurred()) SWIG_fail;
50210 }
50211 resultobj = SWIG_Py_Void();
50212 return resultobj;
50213 fail:
50214 return NULL;
50215 }
50216
50217
50218 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50219 PyObject *resultobj = 0;
50220 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50221 wxButton *arg2 = (wxButton *) 0 ;
50222 void *argp1 = 0 ;
50223 int res1 = 0 ;
50224 void *argp2 = 0 ;
50225 int res2 = 0 ;
50226 PyObject * obj0 = 0 ;
50227 PyObject * obj1 = 0 ;
50228 char * kwnames[] = {
50229 (char *) "self",(char *) "button", NULL
50230 };
50231
50232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50234 if (!SWIG_IsOK(res1)) {
50235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50236 }
50237 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50239 if (!SWIG_IsOK(res2)) {
50240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50241 }
50242 arg2 = reinterpret_cast< wxButton * >(argp2);
50243 {
50244 PyThreadState* __tstate = wxPyBeginAllowThreads();
50245 (arg1)->SetNegativeButton(arg2);
50246 wxPyEndAllowThreads(__tstate);
50247 if (PyErr_Occurred()) SWIG_fail;
50248 }
50249 resultobj = SWIG_Py_Void();
50250 return resultobj;
50251 fail:
50252 return NULL;
50253 }
50254
50255
50256 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50257 PyObject *resultobj = 0;
50258 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50259 wxButton *arg2 = (wxButton *) 0 ;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 void *argp2 = 0 ;
50263 int res2 = 0 ;
50264 PyObject * obj0 = 0 ;
50265 PyObject * obj1 = 0 ;
50266 char * kwnames[] = {
50267 (char *) "self",(char *) "button", NULL
50268 };
50269
50270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50272 if (!SWIG_IsOK(res1)) {
50273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50274 }
50275 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50277 if (!SWIG_IsOK(res2)) {
50278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50279 }
50280 arg2 = reinterpret_cast< wxButton * >(argp2);
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 (arg1)->SetCancelButton(arg2);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 resultobj = SWIG_Py_Void();
50288 return resultobj;
50289 fail:
50290 return NULL;
50291 }
50292
50293
50294 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50295 PyObject *resultobj = 0;
50296 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50297 wxButton *result = 0 ;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 PyObject *swig_obj[1] ;
50301
50302 if (!args) SWIG_fail;
50303 swig_obj[0] = args;
50304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50305 if (!SWIG_IsOK(res1)) {
50306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50307 }
50308 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50309 {
50310 PyThreadState* __tstate = wxPyBeginAllowThreads();
50311 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50312 wxPyEndAllowThreads(__tstate);
50313 if (PyErr_Occurred()) SWIG_fail;
50314 }
50315 {
50316 resultobj = wxPyMake_wxObject(result, (bool)0);
50317 }
50318 return resultobj;
50319 fail:
50320 return NULL;
50321 }
50322
50323
50324 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50325 PyObject *resultobj = 0;
50326 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50327 wxButton *result = 0 ;
50328 void *argp1 = 0 ;
50329 int res1 = 0 ;
50330 PyObject *swig_obj[1] ;
50331
50332 if (!args) SWIG_fail;
50333 swig_obj[0] = args;
50334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50335 if (!SWIG_IsOK(res1)) {
50336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50337 }
50338 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 {
50346 resultobj = wxPyMake_wxObject(result, (bool)0);
50347 }
50348 return resultobj;
50349 fail:
50350 return NULL;
50351 }
50352
50353
50354 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50355 PyObject *resultobj = 0;
50356 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50357 wxButton *result = 0 ;
50358 void *argp1 = 0 ;
50359 int res1 = 0 ;
50360 PyObject *swig_obj[1] ;
50361
50362 if (!args) SWIG_fail;
50363 swig_obj[0] = args;
50364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50365 if (!SWIG_IsOK(res1)) {
50366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50367 }
50368 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50369 {
50370 PyThreadState* __tstate = wxPyBeginAllowThreads();
50371 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50372 wxPyEndAllowThreads(__tstate);
50373 if (PyErr_Occurred()) SWIG_fail;
50374 }
50375 {
50376 resultobj = wxPyMake_wxObject(result, (bool)0);
50377 }
50378 return resultobj;
50379 fail:
50380 return NULL;
50381 }
50382
50383
50384 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50385 PyObject *resultobj = 0;
50386 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50387 wxButton *result = 0 ;
50388 void *argp1 = 0 ;
50389 int res1 = 0 ;
50390 PyObject *swig_obj[1] ;
50391
50392 if (!args) SWIG_fail;
50393 swig_obj[0] = args;
50394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50395 if (!SWIG_IsOK(res1)) {
50396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50397 }
50398 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50399 {
50400 PyThreadState* __tstate = wxPyBeginAllowThreads();
50401 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50402 wxPyEndAllowThreads(__tstate);
50403 if (PyErr_Occurred()) SWIG_fail;
50404 }
50405 {
50406 resultobj = wxPyMake_wxObject(result, (bool)0);
50407 }
50408 return resultobj;
50409 fail:
50410 return NULL;
50411 }
50412
50413
50414 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50415 PyObject *resultobj = 0;
50416 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50417 wxButton *result = 0 ;
50418 void *argp1 = 0 ;
50419 int res1 = 0 ;
50420 PyObject *swig_obj[1] ;
50421
50422 if (!args) SWIG_fail;
50423 swig_obj[0] = args;
50424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50425 if (!SWIG_IsOK(res1)) {
50426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50427 }
50428 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50429 {
50430 PyThreadState* __tstate = wxPyBeginAllowThreads();
50431 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50432 wxPyEndAllowThreads(__tstate);
50433 if (PyErr_Occurred()) SWIG_fail;
50434 }
50435 {
50436 resultobj = wxPyMake_wxObject(result, (bool)0);
50437 }
50438 return resultobj;
50439 fail:
50440 return NULL;
50441 }
50442
50443
50444 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50445 PyObject *obj;
50446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50447 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50448 return SWIG_Py_Void();
50449 }
50450
50451 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50452 return SWIG_Python_InitShadowInstance(args);
50453 }
50454
50455 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50456 PyObject *resultobj = 0;
50457 int arg1 = (int) 0 ;
50458 int arg2 = (int) 0 ;
50459 wxGBPosition *result = 0 ;
50460 int val1 ;
50461 int ecode1 = 0 ;
50462 int val2 ;
50463 int ecode2 = 0 ;
50464 PyObject * obj0 = 0 ;
50465 PyObject * obj1 = 0 ;
50466 char * kwnames[] = {
50467 (char *) "row",(char *) "col", NULL
50468 };
50469
50470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50471 if (obj0) {
50472 ecode1 = SWIG_AsVal_int(obj0, &val1);
50473 if (!SWIG_IsOK(ecode1)) {
50474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50475 }
50476 arg1 = static_cast< int >(val1);
50477 }
50478 if (obj1) {
50479 ecode2 = SWIG_AsVal_int(obj1, &val2);
50480 if (!SWIG_IsOK(ecode2)) {
50481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50482 }
50483 arg2 = static_cast< int >(val2);
50484 }
50485 {
50486 PyThreadState* __tstate = wxPyBeginAllowThreads();
50487 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50488 wxPyEndAllowThreads(__tstate);
50489 if (PyErr_Occurred()) SWIG_fail;
50490 }
50491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50492 return resultobj;
50493 fail:
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50499 PyObject *resultobj = 0;
50500 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50501 void *argp1 = 0 ;
50502 int res1 = 0 ;
50503 PyObject *swig_obj[1] ;
50504
50505 if (!args) SWIG_fail;
50506 swig_obj[0] = args;
50507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50508 if (!SWIG_IsOK(res1)) {
50509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50510 }
50511 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50512 {
50513 PyThreadState* __tstate = wxPyBeginAllowThreads();
50514 delete arg1;
50515
50516 wxPyEndAllowThreads(__tstate);
50517 if (PyErr_Occurred()) SWIG_fail;
50518 }
50519 resultobj = SWIG_Py_Void();
50520 return resultobj;
50521 fail:
50522 return NULL;
50523 }
50524
50525
50526 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50527 PyObject *resultobj = 0;
50528 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50529 int result;
50530 void *argp1 = 0 ;
50531 int res1 = 0 ;
50532 PyObject *swig_obj[1] ;
50533
50534 if (!args) SWIG_fail;
50535 swig_obj[0] = args;
50536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50537 if (!SWIG_IsOK(res1)) {
50538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50539 }
50540 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50541 {
50542 PyThreadState* __tstate = wxPyBeginAllowThreads();
50543 result = (int)((wxGBPosition const *)arg1)->GetRow();
50544 wxPyEndAllowThreads(__tstate);
50545 if (PyErr_Occurred()) SWIG_fail;
50546 }
50547 resultobj = SWIG_From_int(static_cast< int >(result));
50548 return resultobj;
50549 fail:
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50555 PyObject *resultobj = 0;
50556 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50557 int result;
50558 void *argp1 = 0 ;
50559 int res1 = 0 ;
50560 PyObject *swig_obj[1] ;
50561
50562 if (!args) SWIG_fail;
50563 swig_obj[0] = args;
50564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50565 if (!SWIG_IsOK(res1)) {
50566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50567 }
50568 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50569 {
50570 PyThreadState* __tstate = wxPyBeginAllowThreads();
50571 result = (int)((wxGBPosition const *)arg1)->GetCol();
50572 wxPyEndAllowThreads(__tstate);
50573 if (PyErr_Occurred()) SWIG_fail;
50574 }
50575 resultobj = SWIG_From_int(static_cast< int >(result));
50576 return resultobj;
50577 fail:
50578 return NULL;
50579 }
50580
50581
50582 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50583 PyObject *resultobj = 0;
50584 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50585 int arg2 ;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 int val2 ;
50589 int ecode2 = 0 ;
50590 PyObject * obj0 = 0 ;
50591 PyObject * obj1 = 0 ;
50592 char * kwnames[] = {
50593 (char *) "self",(char *) "row", NULL
50594 };
50595
50596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50598 if (!SWIG_IsOK(res1)) {
50599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50600 }
50601 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50602 ecode2 = SWIG_AsVal_int(obj1, &val2);
50603 if (!SWIG_IsOK(ecode2)) {
50604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50605 }
50606 arg2 = static_cast< int >(val2);
50607 {
50608 PyThreadState* __tstate = wxPyBeginAllowThreads();
50609 (arg1)->SetRow(arg2);
50610 wxPyEndAllowThreads(__tstate);
50611 if (PyErr_Occurred()) SWIG_fail;
50612 }
50613 resultobj = SWIG_Py_Void();
50614 return resultobj;
50615 fail:
50616 return NULL;
50617 }
50618
50619
50620 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50621 PyObject *resultobj = 0;
50622 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50623 int arg2 ;
50624 void *argp1 = 0 ;
50625 int res1 = 0 ;
50626 int val2 ;
50627 int ecode2 = 0 ;
50628 PyObject * obj0 = 0 ;
50629 PyObject * obj1 = 0 ;
50630 char * kwnames[] = {
50631 (char *) "self",(char *) "col", NULL
50632 };
50633
50634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50636 if (!SWIG_IsOK(res1)) {
50637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50638 }
50639 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50640 ecode2 = SWIG_AsVal_int(obj1, &val2);
50641 if (!SWIG_IsOK(ecode2)) {
50642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50643 }
50644 arg2 = static_cast< int >(val2);
50645 {
50646 PyThreadState* __tstate = wxPyBeginAllowThreads();
50647 (arg1)->SetCol(arg2);
50648 wxPyEndAllowThreads(__tstate);
50649 if (PyErr_Occurred()) SWIG_fail;
50650 }
50651 resultobj = SWIG_Py_Void();
50652 return resultobj;
50653 fail:
50654 return NULL;
50655 }
50656
50657
50658 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50659 PyObject *resultobj = 0;
50660 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50661 PyObject *arg2 = (PyObject *) 0 ;
50662 bool result;
50663 void *argp1 = 0 ;
50664 int res1 = 0 ;
50665 PyObject * obj0 = 0 ;
50666 PyObject * obj1 = 0 ;
50667 char * kwnames[] = {
50668 (char *) "self",(char *) "other", NULL
50669 };
50670
50671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50673 if (!SWIG_IsOK(res1)) {
50674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50675 }
50676 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50677 arg2 = obj1;
50678 {
50679 result = (bool)wxGBPosition___eq__(arg1,arg2);
50680 if (PyErr_Occurred()) SWIG_fail;
50681 }
50682 {
50683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50684 }
50685 return resultobj;
50686 fail:
50687 return NULL;
50688 }
50689
50690
50691 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50692 PyObject *resultobj = 0;
50693 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50694 PyObject *arg2 = (PyObject *) 0 ;
50695 bool result;
50696 void *argp1 = 0 ;
50697 int res1 = 0 ;
50698 PyObject * obj0 = 0 ;
50699 PyObject * obj1 = 0 ;
50700 char * kwnames[] = {
50701 (char *) "self",(char *) "other", NULL
50702 };
50703
50704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50708 }
50709 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50710 arg2 = obj1;
50711 {
50712 result = (bool)wxGBPosition___ne__(arg1,arg2);
50713 if (PyErr_Occurred()) SWIG_fail;
50714 }
50715 {
50716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50717 }
50718 return resultobj;
50719 fail:
50720 return NULL;
50721 }
50722
50723
50724 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50725 PyObject *resultobj = 0;
50726 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50727 int arg2 = (int) 0 ;
50728 int arg3 = (int) 0 ;
50729 void *argp1 = 0 ;
50730 int res1 = 0 ;
50731 int val2 ;
50732 int ecode2 = 0 ;
50733 int val3 ;
50734 int ecode3 = 0 ;
50735 PyObject * obj0 = 0 ;
50736 PyObject * obj1 = 0 ;
50737 PyObject * obj2 = 0 ;
50738 char * kwnames[] = {
50739 (char *) "self",(char *) "row",(char *) "col", NULL
50740 };
50741
50742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50744 if (!SWIG_IsOK(res1)) {
50745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50746 }
50747 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50748 if (obj1) {
50749 ecode2 = SWIG_AsVal_int(obj1, &val2);
50750 if (!SWIG_IsOK(ecode2)) {
50751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50752 }
50753 arg2 = static_cast< int >(val2);
50754 }
50755 if (obj2) {
50756 ecode3 = SWIG_AsVal_int(obj2, &val3);
50757 if (!SWIG_IsOK(ecode3)) {
50758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50759 }
50760 arg3 = static_cast< int >(val3);
50761 }
50762 {
50763 PyThreadState* __tstate = wxPyBeginAllowThreads();
50764 wxGBPosition_Set(arg1,arg2,arg3);
50765 wxPyEndAllowThreads(__tstate);
50766 if (PyErr_Occurred()) SWIG_fail;
50767 }
50768 resultobj = SWIG_Py_Void();
50769 return resultobj;
50770 fail:
50771 return NULL;
50772 }
50773
50774
50775 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50776 PyObject *resultobj = 0;
50777 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50778 PyObject *result = 0 ;
50779 void *argp1 = 0 ;
50780 int res1 = 0 ;
50781 PyObject *swig_obj[1] ;
50782
50783 if (!args) SWIG_fail;
50784 swig_obj[0] = args;
50785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50786 if (!SWIG_IsOK(res1)) {
50787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50788 }
50789 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50790 {
50791 PyThreadState* __tstate = wxPyBeginAllowThreads();
50792 result = (PyObject *)wxGBPosition_Get(arg1);
50793 wxPyEndAllowThreads(__tstate);
50794 if (PyErr_Occurred()) SWIG_fail;
50795 }
50796 resultobj = result;
50797 return resultobj;
50798 fail:
50799 return NULL;
50800 }
50801
50802
50803 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50804 PyObject *obj;
50805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50806 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50807 return SWIG_Py_Void();
50808 }
50809
50810 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50811 return SWIG_Python_InitShadowInstance(args);
50812 }
50813
50814 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50815 PyObject *resultobj = 0;
50816 int arg1 = (int) 1 ;
50817 int arg2 = (int) 1 ;
50818 wxGBSpan *result = 0 ;
50819 int val1 ;
50820 int ecode1 = 0 ;
50821 int val2 ;
50822 int ecode2 = 0 ;
50823 PyObject * obj0 = 0 ;
50824 PyObject * obj1 = 0 ;
50825 char * kwnames[] = {
50826 (char *) "rowspan",(char *) "colspan", NULL
50827 };
50828
50829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50830 if (obj0) {
50831 ecode1 = SWIG_AsVal_int(obj0, &val1);
50832 if (!SWIG_IsOK(ecode1)) {
50833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50834 }
50835 arg1 = static_cast< int >(val1);
50836 }
50837 if (obj1) {
50838 ecode2 = SWIG_AsVal_int(obj1, &val2);
50839 if (!SWIG_IsOK(ecode2)) {
50840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50841 }
50842 arg2 = static_cast< int >(val2);
50843 }
50844 {
50845 PyThreadState* __tstate = wxPyBeginAllowThreads();
50846 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50847 wxPyEndAllowThreads(__tstate);
50848 if (PyErr_Occurred()) SWIG_fail;
50849 }
50850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50851 return resultobj;
50852 fail:
50853 return NULL;
50854 }
50855
50856
50857 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50858 PyObject *resultobj = 0;
50859 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 PyObject *swig_obj[1] ;
50863
50864 if (!args) SWIG_fail;
50865 swig_obj[0] = args;
50866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50867 if (!SWIG_IsOK(res1)) {
50868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50869 }
50870 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50871 {
50872 PyThreadState* __tstate = wxPyBeginAllowThreads();
50873 delete arg1;
50874
50875 wxPyEndAllowThreads(__tstate);
50876 if (PyErr_Occurred()) SWIG_fail;
50877 }
50878 resultobj = SWIG_Py_Void();
50879 return resultobj;
50880 fail:
50881 return NULL;
50882 }
50883
50884
50885 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50886 PyObject *resultobj = 0;
50887 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50888 int result;
50889 void *argp1 = 0 ;
50890 int res1 = 0 ;
50891 PyObject *swig_obj[1] ;
50892
50893 if (!args) SWIG_fail;
50894 swig_obj[0] = args;
50895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50896 if (!SWIG_IsOK(res1)) {
50897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50898 }
50899 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50900 {
50901 PyThreadState* __tstate = wxPyBeginAllowThreads();
50902 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50903 wxPyEndAllowThreads(__tstate);
50904 if (PyErr_Occurred()) SWIG_fail;
50905 }
50906 resultobj = SWIG_From_int(static_cast< int >(result));
50907 return resultobj;
50908 fail:
50909 return NULL;
50910 }
50911
50912
50913 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50914 PyObject *resultobj = 0;
50915 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50916 int result;
50917 void *argp1 = 0 ;
50918 int res1 = 0 ;
50919 PyObject *swig_obj[1] ;
50920
50921 if (!args) SWIG_fail;
50922 swig_obj[0] = args;
50923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50924 if (!SWIG_IsOK(res1)) {
50925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50926 }
50927 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50928 {
50929 PyThreadState* __tstate = wxPyBeginAllowThreads();
50930 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50931 wxPyEndAllowThreads(__tstate);
50932 if (PyErr_Occurred()) SWIG_fail;
50933 }
50934 resultobj = SWIG_From_int(static_cast< int >(result));
50935 return resultobj;
50936 fail:
50937 return NULL;
50938 }
50939
50940
50941 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50942 PyObject *resultobj = 0;
50943 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50944 int arg2 ;
50945 void *argp1 = 0 ;
50946 int res1 = 0 ;
50947 int val2 ;
50948 int ecode2 = 0 ;
50949 PyObject * obj0 = 0 ;
50950 PyObject * obj1 = 0 ;
50951 char * kwnames[] = {
50952 (char *) "self",(char *) "rowspan", NULL
50953 };
50954
50955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50957 if (!SWIG_IsOK(res1)) {
50958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50959 }
50960 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50961 ecode2 = SWIG_AsVal_int(obj1, &val2);
50962 if (!SWIG_IsOK(ecode2)) {
50963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50964 }
50965 arg2 = static_cast< int >(val2);
50966 {
50967 PyThreadState* __tstate = wxPyBeginAllowThreads();
50968 (arg1)->SetRowspan(arg2);
50969 wxPyEndAllowThreads(__tstate);
50970 if (PyErr_Occurred()) SWIG_fail;
50971 }
50972 resultobj = SWIG_Py_Void();
50973 return resultobj;
50974 fail:
50975 return NULL;
50976 }
50977
50978
50979 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50980 PyObject *resultobj = 0;
50981 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50982 int arg2 ;
50983 void *argp1 = 0 ;
50984 int res1 = 0 ;
50985 int val2 ;
50986 int ecode2 = 0 ;
50987 PyObject * obj0 = 0 ;
50988 PyObject * obj1 = 0 ;
50989 char * kwnames[] = {
50990 (char *) "self",(char *) "colspan", NULL
50991 };
50992
50993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50995 if (!SWIG_IsOK(res1)) {
50996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50997 }
50998 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50999 ecode2 = SWIG_AsVal_int(obj1, &val2);
51000 if (!SWIG_IsOK(ecode2)) {
51001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
51002 }
51003 arg2 = static_cast< int >(val2);
51004 {
51005 PyThreadState* __tstate = wxPyBeginAllowThreads();
51006 (arg1)->SetColspan(arg2);
51007 wxPyEndAllowThreads(__tstate);
51008 if (PyErr_Occurred()) SWIG_fail;
51009 }
51010 resultobj = SWIG_Py_Void();
51011 return resultobj;
51012 fail:
51013 return NULL;
51014 }
51015
51016
51017 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51018 PyObject *resultobj = 0;
51019 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51020 PyObject *arg2 = (PyObject *) 0 ;
51021 bool result;
51022 void *argp1 = 0 ;
51023 int res1 = 0 ;
51024 PyObject * obj0 = 0 ;
51025 PyObject * obj1 = 0 ;
51026 char * kwnames[] = {
51027 (char *) "self",(char *) "other", NULL
51028 };
51029
51030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51032 if (!SWIG_IsOK(res1)) {
51033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51034 }
51035 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51036 arg2 = obj1;
51037 {
51038 result = (bool)wxGBSpan___eq__(arg1,arg2);
51039 if (PyErr_Occurred()) SWIG_fail;
51040 }
51041 {
51042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51043 }
51044 return resultobj;
51045 fail:
51046 return NULL;
51047 }
51048
51049
51050 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51051 PyObject *resultobj = 0;
51052 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51053 PyObject *arg2 = (PyObject *) 0 ;
51054 bool result;
51055 void *argp1 = 0 ;
51056 int res1 = 0 ;
51057 PyObject * obj0 = 0 ;
51058 PyObject * obj1 = 0 ;
51059 char * kwnames[] = {
51060 (char *) "self",(char *) "other", NULL
51061 };
51062
51063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51065 if (!SWIG_IsOK(res1)) {
51066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51067 }
51068 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51069 arg2 = obj1;
51070 {
51071 result = (bool)wxGBSpan___ne__(arg1,arg2);
51072 if (PyErr_Occurred()) SWIG_fail;
51073 }
51074 {
51075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51076 }
51077 return resultobj;
51078 fail:
51079 return NULL;
51080 }
51081
51082
51083 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51084 PyObject *resultobj = 0;
51085 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51086 int arg2 = (int) 1 ;
51087 int arg3 = (int) 1 ;
51088 void *argp1 = 0 ;
51089 int res1 = 0 ;
51090 int val2 ;
51091 int ecode2 = 0 ;
51092 int val3 ;
51093 int ecode3 = 0 ;
51094 PyObject * obj0 = 0 ;
51095 PyObject * obj1 = 0 ;
51096 PyObject * obj2 = 0 ;
51097 char * kwnames[] = {
51098 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51099 };
51100
51101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51103 if (!SWIG_IsOK(res1)) {
51104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51105 }
51106 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51107 if (obj1) {
51108 ecode2 = SWIG_AsVal_int(obj1, &val2);
51109 if (!SWIG_IsOK(ecode2)) {
51110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51111 }
51112 arg2 = static_cast< int >(val2);
51113 }
51114 if (obj2) {
51115 ecode3 = SWIG_AsVal_int(obj2, &val3);
51116 if (!SWIG_IsOK(ecode3)) {
51117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51118 }
51119 arg3 = static_cast< int >(val3);
51120 }
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 wxGBSpan_Set(arg1,arg2,arg3);
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = SWIG_Py_Void();
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51135 PyObject *resultobj = 0;
51136 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51137 PyObject *result = 0 ;
51138 void *argp1 = 0 ;
51139 int res1 = 0 ;
51140 PyObject *swig_obj[1] ;
51141
51142 if (!args) SWIG_fail;
51143 swig_obj[0] = args;
51144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51147 }
51148 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51149 {
51150 PyThreadState* __tstate = wxPyBeginAllowThreads();
51151 result = (PyObject *)wxGBSpan_Get(arg1);
51152 wxPyEndAllowThreads(__tstate);
51153 if (PyErr_Occurred()) SWIG_fail;
51154 }
51155 resultobj = result;
51156 return resultobj;
51157 fail:
51158 return NULL;
51159 }
51160
51161
51162 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51163 PyObject *obj;
51164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51165 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51166 return SWIG_Py_Void();
51167 }
51168
51169 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51170 return SWIG_Python_InitShadowInstance(args);
51171 }
51172
51173 SWIGINTERN int DefaultSpan_set(PyObject *) {
51174 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51175 return 1;
51176 }
51177
51178
51179 SWIGINTERN PyObject *DefaultSpan_get(void) {
51180 PyObject *pyobj = 0;
51181
51182 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51183 return pyobj;
51184 }
51185
51186
51187 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51188 PyObject *resultobj = 0;
51189 wxGBSizerItem *result = 0 ;
51190
51191 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51192 {
51193 PyThreadState* __tstate = wxPyBeginAllowThreads();
51194 result = (wxGBSizerItem *)new wxGBSizerItem();
51195 wxPyEndAllowThreads(__tstate);
51196 if (PyErr_Occurred()) SWIG_fail;
51197 }
51198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51199 return resultobj;
51200 fail:
51201 return NULL;
51202 }
51203
51204
51205 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51206 PyObject *resultobj = 0;
51207 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51208 void *argp1 = 0 ;
51209 int res1 = 0 ;
51210 PyObject *swig_obj[1] ;
51211
51212 if (!args) SWIG_fail;
51213 swig_obj[0] = args;
51214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51215 if (!SWIG_IsOK(res1)) {
51216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51217 }
51218 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51219 {
51220 PyThreadState* __tstate = wxPyBeginAllowThreads();
51221 delete arg1;
51222
51223 wxPyEndAllowThreads(__tstate);
51224 if (PyErr_Occurred()) SWIG_fail;
51225 }
51226 resultobj = SWIG_Py_Void();
51227 return resultobj;
51228 fail:
51229 return NULL;
51230 }
51231
51232
51233 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51234 PyObject *resultobj = 0;
51235 wxWindow *arg1 = (wxWindow *) 0 ;
51236 wxGBPosition *arg2 = 0 ;
51237 wxGBSpan *arg3 = 0 ;
51238 int arg4 ;
51239 int arg5 ;
51240 PyObject *arg6 = (PyObject *) NULL ;
51241 wxGBSizerItem *result = 0 ;
51242 void *argp1 = 0 ;
51243 int res1 = 0 ;
51244 wxGBPosition temp2 ;
51245 wxGBSpan temp3 ;
51246 int val4 ;
51247 int ecode4 = 0 ;
51248 int val5 ;
51249 int ecode5 = 0 ;
51250 PyObject * obj0 = 0 ;
51251 PyObject * obj1 = 0 ;
51252 PyObject * obj2 = 0 ;
51253 PyObject * obj3 = 0 ;
51254 PyObject * obj4 = 0 ;
51255 PyObject * obj5 = 0 ;
51256 char * kwnames[] = {
51257 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51258 };
51259
51260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51262 if (!SWIG_IsOK(res1)) {
51263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51264 }
51265 arg1 = reinterpret_cast< wxWindow * >(argp1);
51266 {
51267 arg2 = &temp2;
51268 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51269 }
51270 {
51271 arg3 = &temp3;
51272 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51273 }
51274 ecode4 = SWIG_AsVal_int(obj3, &val4);
51275 if (!SWIG_IsOK(ecode4)) {
51276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51277 }
51278 arg4 = static_cast< int >(val4);
51279 ecode5 = SWIG_AsVal_int(obj4, &val5);
51280 if (!SWIG_IsOK(ecode5)) {
51281 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51282 }
51283 arg5 = static_cast< int >(val5);
51284 if (obj5) {
51285 arg6 = obj5;
51286 }
51287 {
51288 PyThreadState* __tstate = wxPyBeginAllowThreads();
51289 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51290 wxPyEndAllowThreads(__tstate);
51291 if (PyErr_Occurred()) SWIG_fail;
51292 }
51293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51294 return resultobj;
51295 fail:
51296 return NULL;
51297 }
51298
51299
51300 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51301 PyObject *resultobj = 0;
51302 wxSizer *arg1 = (wxSizer *) 0 ;
51303 wxGBPosition *arg2 = 0 ;
51304 wxGBSpan *arg3 = 0 ;
51305 int arg4 ;
51306 int arg5 ;
51307 PyObject *arg6 = (PyObject *) NULL ;
51308 wxGBSizerItem *result = 0 ;
51309 int res1 = 0 ;
51310 wxGBPosition temp2 ;
51311 wxGBSpan temp3 ;
51312 int val4 ;
51313 int ecode4 = 0 ;
51314 int val5 ;
51315 int ecode5 = 0 ;
51316 PyObject * obj0 = 0 ;
51317 PyObject * obj1 = 0 ;
51318 PyObject * obj2 = 0 ;
51319 PyObject * obj3 = 0 ;
51320 PyObject * obj4 = 0 ;
51321 PyObject * obj5 = 0 ;
51322 char * kwnames[] = {
51323 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51324 };
51325
51326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51327 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51328 if (!SWIG_IsOK(res1)) {
51329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51330 }
51331 {
51332 arg2 = &temp2;
51333 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51334 }
51335 {
51336 arg3 = &temp3;
51337 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51338 }
51339 ecode4 = SWIG_AsVal_int(obj3, &val4);
51340 if (!SWIG_IsOK(ecode4)) {
51341 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51342 }
51343 arg4 = static_cast< int >(val4);
51344 ecode5 = SWIG_AsVal_int(obj4, &val5);
51345 if (!SWIG_IsOK(ecode5)) {
51346 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51347 }
51348 arg5 = static_cast< int >(val5);
51349 if (obj5) {
51350 arg6 = obj5;
51351 }
51352 {
51353 PyThreadState* __tstate = wxPyBeginAllowThreads();
51354 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51355 wxPyEndAllowThreads(__tstate);
51356 if (PyErr_Occurred()) SWIG_fail;
51357 }
51358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51359 return resultobj;
51360 fail:
51361 return NULL;
51362 }
51363
51364
51365 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51366 PyObject *resultobj = 0;
51367 int arg1 ;
51368 int arg2 ;
51369 wxGBPosition *arg3 = 0 ;
51370 wxGBSpan *arg4 = 0 ;
51371 int arg5 ;
51372 int arg6 ;
51373 PyObject *arg7 = (PyObject *) NULL ;
51374 wxGBSizerItem *result = 0 ;
51375 int val1 ;
51376 int ecode1 = 0 ;
51377 int val2 ;
51378 int ecode2 = 0 ;
51379 wxGBPosition temp3 ;
51380 wxGBSpan temp4 ;
51381 int val5 ;
51382 int ecode5 = 0 ;
51383 int val6 ;
51384 int ecode6 = 0 ;
51385 PyObject * obj0 = 0 ;
51386 PyObject * obj1 = 0 ;
51387 PyObject * obj2 = 0 ;
51388 PyObject * obj3 = 0 ;
51389 PyObject * obj4 = 0 ;
51390 PyObject * obj5 = 0 ;
51391 PyObject * obj6 = 0 ;
51392 char * kwnames[] = {
51393 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51394 };
51395
51396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51397 ecode1 = SWIG_AsVal_int(obj0, &val1);
51398 if (!SWIG_IsOK(ecode1)) {
51399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51400 }
51401 arg1 = static_cast< int >(val1);
51402 ecode2 = SWIG_AsVal_int(obj1, &val2);
51403 if (!SWIG_IsOK(ecode2)) {
51404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51405 }
51406 arg2 = static_cast< int >(val2);
51407 {
51408 arg3 = &temp3;
51409 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51410 }
51411 {
51412 arg4 = &temp4;
51413 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51414 }
51415 ecode5 = SWIG_AsVal_int(obj4, &val5);
51416 if (!SWIG_IsOK(ecode5)) {
51417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51418 }
51419 arg5 = static_cast< int >(val5);
51420 ecode6 = SWIG_AsVal_int(obj5, &val6);
51421 if (!SWIG_IsOK(ecode6)) {
51422 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51423 }
51424 arg6 = static_cast< int >(val6);
51425 if (obj6) {
51426 arg7 = obj6;
51427 }
51428 {
51429 PyThreadState* __tstate = wxPyBeginAllowThreads();
51430 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51431 wxPyEndAllowThreads(__tstate);
51432 if (PyErr_Occurred()) SWIG_fail;
51433 }
51434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51435 return resultobj;
51436 fail:
51437 return NULL;
51438 }
51439
51440
51441 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51442 PyObject *resultobj = 0;
51443 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51444 wxGBPosition result;
51445 void *argp1 = 0 ;
51446 int res1 = 0 ;
51447 PyObject *swig_obj[1] ;
51448
51449 if (!args) SWIG_fail;
51450 swig_obj[0] = args;
51451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51452 if (!SWIG_IsOK(res1)) {
51453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51454 }
51455 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51456 {
51457 PyThreadState* __tstate = wxPyBeginAllowThreads();
51458 result = ((wxGBSizerItem const *)arg1)->GetPos();
51459 wxPyEndAllowThreads(__tstate);
51460 if (PyErr_Occurred()) SWIG_fail;
51461 }
51462 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51463 return resultobj;
51464 fail:
51465 return NULL;
51466 }
51467
51468
51469 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51470 PyObject *resultobj = 0;
51471 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51472 wxGBSpan result;
51473 void *argp1 = 0 ;
51474 int res1 = 0 ;
51475 PyObject *swig_obj[1] ;
51476
51477 if (!args) SWIG_fail;
51478 swig_obj[0] = args;
51479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51480 if (!SWIG_IsOK(res1)) {
51481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51482 }
51483 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51484 {
51485 PyThreadState* __tstate = wxPyBeginAllowThreads();
51486 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51487 wxPyEndAllowThreads(__tstate);
51488 if (PyErr_Occurred()) SWIG_fail;
51489 }
51490 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51491 return resultobj;
51492 fail:
51493 return NULL;
51494 }
51495
51496
51497 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51498 PyObject *resultobj = 0;
51499 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51500 wxGBPosition *arg2 = 0 ;
51501 bool result;
51502 void *argp1 = 0 ;
51503 int res1 = 0 ;
51504 wxGBPosition temp2 ;
51505 PyObject * obj0 = 0 ;
51506 PyObject * obj1 = 0 ;
51507 char * kwnames[] = {
51508 (char *) "self",(char *) "pos", NULL
51509 };
51510
51511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51513 if (!SWIG_IsOK(res1)) {
51514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51515 }
51516 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51517 {
51518 arg2 = &temp2;
51519 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51520 }
51521 {
51522 PyThreadState* __tstate = wxPyBeginAllowThreads();
51523 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51524 wxPyEndAllowThreads(__tstate);
51525 if (PyErr_Occurred()) SWIG_fail;
51526 }
51527 {
51528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51529 }
51530 return resultobj;
51531 fail:
51532 return NULL;
51533 }
51534
51535
51536 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51537 PyObject *resultobj = 0;
51538 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51539 wxGBSpan *arg2 = 0 ;
51540 bool result;
51541 void *argp1 = 0 ;
51542 int res1 = 0 ;
51543 wxGBSpan temp2 ;
51544 PyObject * obj0 = 0 ;
51545 PyObject * obj1 = 0 ;
51546 char * kwnames[] = {
51547 (char *) "self",(char *) "span", NULL
51548 };
51549
51550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51552 if (!SWIG_IsOK(res1)) {
51553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51554 }
51555 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51556 {
51557 arg2 = &temp2;
51558 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51559 }
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51563 wxPyEndAllowThreads(__tstate);
51564 if (PyErr_Occurred()) SWIG_fail;
51565 }
51566 {
51567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51568 }
51569 return resultobj;
51570 fail:
51571 return NULL;
51572 }
51573
51574
51575 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51576 PyObject *resultobj = 0;
51577 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51578 wxGBSizerItem *arg2 = 0 ;
51579 bool result;
51580 void *argp1 = 0 ;
51581 int res1 = 0 ;
51582 void *argp2 = 0 ;
51583 int res2 = 0 ;
51584 PyObject * obj0 = 0 ;
51585 PyObject * obj1 = 0 ;
51586 char * kwnames[] = {
51587 (char *) "self",(char *) "other", NULL
51588 };
51589
51590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51592 if (!SWIG_IsOK(res1)) {
51593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51594 }
51595 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51597 if (!SWIG_IsOK(res2)) {
51598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51599 }
51600 if (!argp2) {
51601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51602 }
51603 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51604 {
51605 PyThreadState* __tstate = wxPyBeginAllowThreads();
51606 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51607 wxPyEndAllowThreads(__tstate);
51608 if (PyErr_Occurred()) SWIG_fail;
51609 }
51610 {
51611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51612 }
51613 return resultobj;
51614 fail:
51615 return NULL;
51616 }
51617
51618
51619 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51620 PyObject *resultobj = 0;
51621 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51622 wxGBPosition *arg2 = 0 ;
51623 wxGBSpan *arg3 = 0 ;
51624 bool result;
51625 void *argp1 = 0 ;
51626 int res1 = 0 ;
51627 wxGBPosition temp2 ;
51628 wxGBSpan temp3 ;
51629 PyObject * obj0 = 0 ;
51630 PyObject * obj1 = 0 ;
51631 PyObject * obj2 = 0 ;
51632 char * kwnames[] = {
51633 (char *) "self",(char *) "pos",(char *) "span", NULL
51634 };
51635
51636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51638 if (!SWIG_IsOK(res1)) {
51639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51640 }
51641 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51642 {
51643 arg2 = &temp2;
51644 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51645 }
51646 {
51647 arg3 = &temp3;
51648 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51649 }
51650 {
51651 PyThreadState* __tstate = wxPyBeginAllowThreads();
51652 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51653 wxPyEndAllowThreads(__tstate);
51654 if (PyErr_Occurred()) SWIG_fail;
51655 }
51656 {
51657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51658 }
51659 return resultobj;
51660 fail:
51661 return NULL;
51662 }
51663
51664
51665 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51666 PyObject *resultobj = 0;
51667 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51668 wxGBPosition result;
51669 void *argp1 = 0 ;
51670 int res1 = 0 ;
51671 PyObject *swig_obj[1] ;
51672
51673 if (!args) SWIG_fail;
51674 swig_obj[0] = args;
51675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51676 if (!SWIG_IsOK(res1)) {
51677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51678 }
51679 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51680 {
51681 PyThreadState* __tstate = wxPyBeginAllowThreads();
51682 result = wxGBSizerItem_GetEndPos(arg1);
51683 wxPyEndAllowThreads(__tstate);
51684 if (PyErr_Occurred()) SWIG_fail;
51685 }
51686 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51687 return resultobj;
51688 fail:
51689 return NULL;
51690 }
51691
51692
51693 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51694 PyObject *resultobj = 0;
51695 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51696 wxGridBagSizer *result = 0 ;
51697 void *argp1 = 0 ;
51698 int res1 = 0 ;
51699 PyObject *swig_obj[1] ;
51700
51701 if (!args) SWIG_fail;
51702 swig_obj[0] = args;
51703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51704 if (!SWIG_IsOK(res1)) {
51705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51706 }
51707 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51708 {
51709 PyThreadState* __tstate = wxPyBeginAllowThreads();
51710 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51711 wxPyEndAllowThreads(__tstate);
51712 if (PyErr_Occurred()) SWIG_fail;
51713 }
51714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51715 return resultobj;
51716 fail:
51717 return NULL;
51718 }
51719
51720
51721 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51722 PyObject *resultobj = 0;
51723 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51724 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51725 void *argp1 = 0 ;
51726 int res1 = 0 ;
51727 void *argp2 = 0 ;
51728 int res2 = 0 ;
51729 PyObject * obj0 = 0 ;
51730 PyObject * obj1 = 0 ;
51731 char * kwnames[] = {
51732 (char *) "self",(char *) "sizer", NULL
51733 };
51734
51735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51737 if (!SWIG_IsOK(res1)) {
51738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51739 }
51740 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51742 if (!SWIG_IsOK(res2)) {
51743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51744 }
51745 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51746 {
51747 PyThreadState* __tstate = wxPyBeginAllowThreads();
51748 (arg1)->SetGBSizer(arg2);
51749 wxPyEndAllowThreads(__tstate);
51750 if (PyErr_Occurred()) SWIG_fail;
51751 }
51752 resultobj = SWIG_Py_Void();
51753 return resultobj;
51754 fail:
51755 return NULL;
51756 }
51757
51758
51759 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51760 PyObject *obj;
51761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51762 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51763 return SWIG_Py_Void();
51764 }
51765
51766 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51767 return SWIG_Python_InitShadowInstance(args);
51768 }
51769
51770 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51771 PyObject *resultobj = 0;
51772 int arg1 = (int) 0 ;
51773 int arg2 = (int) 0 ;
51774 wxGridBagSizer *result = 0 ;
51775 int val1 ;
51776 int ecode1 = 0 ;
51777 int val2 ;
51778 int ecode2 = 0 ;
51779 PyObject * obj0 = 0 ;
51780 PyObject * obj1 = 0 ;
51781 char * kwnames[] = {
51782 (char *) "vgap",(char *) "hgap", NULL
51783 };
51784
51785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51786 if (obj0) {
51787 ecode1 = SWIG_AsVal_int(obj0, &val1);
51788 if (!SWIG_IsOK(ecode1)) {
51789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51790 }
51791 arg1 = static_cast< int >(val1);
51792 }
51793 if (obj1) {
51794 ecode2 = SWIG_AsVal_int(obj1, &val2);
51795 if (!SWIG_IsOK(ecode2)) {
51796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51797 }
51798 arg2 = static_cast< int >(val2);
51799 }
51800 {
51801 PyThreadState* __tstate = wxPyBeginAllowThreads();
51802 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51803 wxPyEndAllowThreads(__tstate);
51804 if (PyErr_Occurred()) SWIG_fail;
51805 }
51806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51807 return resultobj;
51808 fail:
51809 return NULL;
51810 }
51811
51812
51813 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51814 PyObject *resultobj = 0;
51815 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51816 PyObject *arg2 = (PyObject *) 0 ;
51817 wxGBPosition *arg3 = 0 ;
51818 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51819 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51820 int arg5 = (int) 0 ;
51821 int arg6 = (int) 0 ;
51822 PyObject *arg7 = (PyObject *) NULL ;
51823 wxGBSizerItem *result = 0 ;
51824 void *argp1 = 0 ;
51825 int res1 = 0 ;
51826 wxGBPosition temp3 ;
51827 wxGBSpan temp4 ;
51828 int val5 ;
51829 int ecode5 = 0 ;
51830 int val6 ;
51831 int ecode6 = 0 ;
51832 PyObject * obj0 = 0 ;
51833 PyObject * obj1 = 0 ;
51834 PyObject * obj2 = 0 ;
51835 PyObject * obj3 = 0 ;
51836 PyObject * obj4 = 0 ;
51837 PyObject * obj5 = 0 ;
51838 PyObject * obj6 = 0 ;
51839 char * kwnames[] = {
51840 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51841 };
51842
51843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51845 if (!SWIG_IsOK(res1)) {
51846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51847 }
51848 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51849 arg2 = obj1;
51850 {
51851 arg3 = &temp3;
51852 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51853 }
51854 if (obj3) {
51855 {
51856 arg4 = &temp4;
51857 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51858 }
51859 }
51860 if (obj4) {
51861 ecode5 = SWIG_AsVal_int(obj4, &val5);
51862 if (!SWIG_IsOK(ecode5)) {
51863 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51864 }
51865 arg5 = static_cast< int >(val5);
51866 }
51867 if (obj5) {
51868 ecode6 = SWIG_AsVal_int(obj5, &val6);
51869 if (!SWIG_IsOK(ecode6)) {
51870 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51871 }
51872 arg6 = static_cast< int >(val6);
51873 }
51874 if (obj6) {
51875 arg7 = obj6;
51876 }
51877 {
51878 PyThreadState* __tstate = wxPyBeginAllowThreads();
51879 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51880 wxPyEndAllowThreads(__tstate);
51881 if (PyErr_Occurred()) SWIG_fail;
51882 }
51883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51884 return resultobj;
51885 fail:
51886 return NULL;
51887 }
51888
51889
51890 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51891 PyObject *resultobj = 0;
51892 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51893 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51894 wxGBSizerItem *result = 0 ;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 int res2 = 0 ;
51898 PyObject * obj0 = 0 ;
51899 PyObject * obj1 = 0 ;
51900 char * kwnames[] = {
51901 (char *) "self",(char *) "item", NULL
51902 };
51903
51904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51906 if (!SWIG_IsOK(res1)) {
51907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51908 }
51909 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51910 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51911 if (!SWIG_IsOK(res2)) {
51912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51913 }
51914 {
51915 PyThreadState* __tstate = wxPyBeginAllowThreads();
51916 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51917 wxPyEndAllowThreads(__tstate);
51918 if (PyErr_Occurred()) SWIG_fail;
51919 }
51920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51921 return resultobj;
51922 fail:
51923 return NULL;
51924 }
51925
51926
51927 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51928 PyObject *resultobj = 0;
51929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51930 int arg2 ;
51931 int arg3 ;
51932 wxSize result;
51933 void *argp1 = 0 ;
51934 int res1 = 0 ;
51935 int val2 ;
51936 int ecode2 = 0 ;
51937 int val3 ;
51938 int ecode3 = 0 ;
51939 PyObject * obj0 = 0 ;
51940 PyObject * obj1 = 0 ;
51941 PyObject * obj2 = 0 ;
51942 char * kwnames[] = {
51943 (char *) "self",(char *) "row",(char *) "col", NULL
51944 };
51945
51946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51948 if (!SWIG_IsOK(res1)) {
51949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51950 }
51951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51952 ecode2 = SWIG_AsVal_int(obj1, &val2);
51953 if (!SWIG_IsOK(ecode2)) {
51954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51955 }
51956 arg2 = static_cast< int >(val2);
51957 ecode3 = SWIG_AsVal_int(obj2, &val3);
51958 if (!SWIG_IsOK(ecode3)) {
51959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51960 }
51961 arg3 = static_cast< int >(val3);
51962 {
51963 PyThreadState* __tstate = wxPyBeginAllowThreads();
51964 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51965 wxPyEndAllowThreads(__tstate);
51966 if (PyErr_Occurred()) SWIG_fail;
51967 }
51968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51969 return resultobj;
51970 fail:
51971 return NULL;
51972 }
51973
51974
51975 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51976 PyObject *resultobj = 0;
51977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51978 wxSize result;
51979 void *argp1 = 0 ;
51980 int res1 = 0 ;
51981 PyObject *swig_obj[1] ;
51982
51983 if (!args) SWIG_fail;
51984 swig_obj[0] = args;
51985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51986 if (!SWIG_IsOK(res1)) {
51987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51988 }
51989 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51990 {
51991 PyThreadState* __tstate = wxPyBeginAllowThreads();
51992 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51993 wxPyEndAllowThreads(__tstate);
51994 if (PyErr_Occurred()) SWIG_fail;
51995 }
51996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51997 return resultobj;
51998 fail:
51999 return NULL;
52000 }
52001
52002
52003 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52004 PyObject *resultobj = 0;
52005 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52006 wxSize *arg2 = 0 ;
52007 void *argp1 = 0 ;
52008 int res1 = 0 ;
52009 wxSize temp2 ;
52010 PyObject * obj0 = 0 ;
52011 PyObject * obj1 = 0 ;
52012 char * kwnames[] = {
52013 (char *) "self",(char *) "sz", NULL
52014 };
52015
52016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
52017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52018 if (!SWIG_IsOK(res1)) {
52019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52020 }
52021 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52022 {
52023 arg2 = &temp2;
52024 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52025 }
52026 {
52027 PyThreadState* __tstate = wxPyBeginAllowThreads();
52028 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52029 wxPyEndAllowThreads(__tstate);
52030 if (PyErr_Occurred()) SWIG_fail;
52031 }
52032 resultobj = SWIG_Py_Void();
52033 return resultobj;
52034 fail:
52035 return NULL;
52036 }
52037
52038
52039 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52040 PyObject *resultobj = 0;
52041 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52042 wxWindow *arg2 = (wxWindow *) 0 ;
52043 wxGBPosition result;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 void *argp2 = 0 ;
52047 int res2 = 0 ;
52048
52049 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52053 }
52054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52055 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52056 if (!SWIG_IsOK(res2)) {
52057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52058 }
52059 arg2 = reinterpret_cast< wxWindow * >(argp2);
52060 {
52061 PyThreadState* __tstate = wxPyBeginAllowThreads();
52062 result = (arg1)->GetItemPosition(arg2);
52063 wxPyEndAllowThreads(__tstate);
52064 if (PyErr_Occurred()) SWIG_fail;
52065 }
52066 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52067 return resultobj;
52068 fail:
52069 return NULL;
52070 }
52071
52072
52073 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52074 PyObject *resultobj = 0;
52075 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52076 wxSizer *arg2 = (wxSizer *) 0 ;
52077 wxGBPosition result;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 void *argp2 = 0 ;
52081 int res2 = 0 ;
52082
52083 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52085 if (!SWIG_IsOK(res1)) {
52086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52087 }
52088 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52089 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52090 if (!SWIG_IsOK(res2)) {
52091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52092 }
52093 arg2 = reinterpret_cast< wxSizer * >(argp2);
52094 {
52095 PyThreadState* __tstate = wxPyBeginAllowThreads();
52096 result = (arg1)->GetItemPosition(arg2);
52097 wxPyEndAllowThreads(__tstate);
52098 if (PyErr_Occurred()) SWIG_fail;
52099 }
52100 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52101 return resultobj;
52102 fail:
52103 return NULL;
52104 }
52105
52106
52107 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52108 PyObject *resultobj = 0;
52109 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52110 size_t arg2 ;
52111 wxGBPosition result;
52112 void *argp1 = 0 ;
52113 int res1 = 0 ;
52114 size_t val2 ;
52115 int ecode2 = 0 ;
52116
52117 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52119 if (!SWIG_IsOK(res1)) {
52120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52121 }
52122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52123 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52124 if (!SWIG_IsOK(ecode2)) {
52125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52126 }
52127 arg2 = static_cast< size_t >(val2);
52128 {
52129 PyThreadState* __tstate = wxPyBeginAllowThreads();
52130 result = (arg1)->GetItemPosition(arg2);
52131 wxPyEndAllowThreads(__tstate);
52132 if (PyErr_Occurred()) SWIG_fail;
52133 }
52134 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52142 int argc;
52143 PyObject *argv[3];
52144
52145 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52146 --argc;
52147 if (argc == 2) {
52148 int _v = 0;
52149 {
52150 void *vptr = 0;
52151 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52152 _v = SWIG_CheckState(res);
52153 }
52154 if (!_v) goto check_1;
52155 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52156 }
52157 check_1:
52158
52159 if (argc == 2) {
52160 int _v = 0;
52161 {
52162 void *vptr = 0;
52163 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52164 _v = SWIG_CheckState(res);
52165 }
52166 if (!_v) goto check_2;
52167 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52168 }
52169 check_2:
52170
52171 if (argc == 2) {
52172 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52173 }
52174
52175 fail:
52176 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52177 return NULL;
52178 }
52179
52180
52181 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52182 PyObject *resultobj = 0;
52183 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52184 wxWindow *arg2 = (wxWindow *) 0 ;
52185 wxGBPosition *arg3 = 0 ;
52186 bool result;
52187 void *argp1 = 0 ;
52188 int res1 = 0 ;
52189 void *argp2 = 0 ;
52190 int res2 = 0 ;
52191 wxGBPosition temp3 ;
52192
52193 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52195 if (!SWIG_IsOK(res1)) {
52196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52197 }
52198 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52199 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52200 if (!SWIG_IsOK(res2)) {
52201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52202 }
52203 arg2 = reinterpret_cast< wxWindow * >(argp2);
52204 {
52205 arg3 = &temp3;
52206 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52207 }
52208 {
52209 PyThreadState* __tstate = wxPyBeginAllowThreads();
52210 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52211 wxPyEndAllowThreads(__tstate);
52212 if (PyErr_Occurred()) SWIG_fail;
52213 }
52214 {
52215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52216 }
52217 return resultobj;
52218 fail:
52219 return NULL;
52220 }
52221
52222
52223 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52224 PyObject *resultobj = 0;
52225 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52226 wxSizer *arg2 = (wxSizer *) 0 ;
52227 wxGBPosition *arg3 = 0 ;
52228 bool result;
52229 void *argp1 = 0 ;
52230 int res1 = 0 ;
52231 void *argp2 = 0 ;
52232 int res2 = 0 ;
52233 wxGBPosition temp3 ;
52234
52235 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52237 if (!SWIG_IsOK(res1)) {
52238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52239 }
52240 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52241 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52242 if (!SWIG_IsOK(res2)) {
52243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52244 }
52245 arg2 = reinterpret_cast< wxSizer * >(argp2);
52246 {
52247 arg3 = &temp3;
52248 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52249 }
52250 {
52251 PyThreadState* __tstate = wxPyBeginAllowThreads();
52252 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52253 wxPyEndAllowThreads(__tstate);
52254 if (PyErr_Occurred()) SWIG_fail;
52255 }
52256 {
52257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52258 }
52259 return resultobj;
52260 fail:
52261 return NULL;
52262 }
52263
52264
52265 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52266 PyObject *resultobj = 0;
52267 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52268 size_t arg2 ;
52269 wxGBPosition *arg3 = 0 ;
52270 bool result;
52271 void *argp1 = 0 ;
52272 int res1 = 0 ;
52273 size_t val2 ;
52274 int ecode2 = 0 ;
52275 wxGBPosition temp3 ;
52276
52277 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52281 }
52282 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52283 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52284 if (!SWIG_IsOK(ecode2)) {
52285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52286 }
52287 arg2 = static_cast< size_t >(val2);
52288 {
52289 arg3 = &temp3;
52290 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52291 }
52292 {
52293 PyThreadState* __tstate = wxPyBeginAllowThreads();
52294 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52295 wxPyEndAllowThreads(__tstate);
52296 if (PyErr_Occurred()) SWIG_fail;
52297 }
52298 {
52299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52300 }
52301 return resultobj;
52302 fail:
52303 return NULL;
52304 }
52305
52306
52307 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52308 int argc;
52309 PyObject *argv[4];
52310
52311 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52312 --argc;
52313 if (argc == 3) {
52314 int _v = 0;
52315 {
52316 void *vptr = 0;
52317 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52318 _v = SWIG_CheckState(res);
52319 }
52320 if (!_v) goto check_1;
52321 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52322 }
52323 check_1:
52324
52325 if (argc == 3) {
52326 int _v = 0;
52327 {
52328 void *vptr = 0;
52329 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52330 _v = SWIG_CheckState(res);
52331 }
52332 if (!_v) goto check_2;
52333 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52334 }
52335 check_2:
52336
52337 if (argc == 3) {
52338 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52339 }
52340
52341 fail:
52342 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52343 return NULL;
52344 }
52345
52346
52347 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52348 PyObject *resultobj = 0;
52349 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52350 wxWindow *arg2 = (wxWindow *) 0 ;
52351 wxGBSpan result;
52352 void *argp1 = 0 ;
52353 int res1 = 0 ;
52354 void *argp2 = 0 ;
52355 int res2 = 0 ;
52356
52357 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52359 if (!SWIG_IsOK(res1)) {
52360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52361 }
52362 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52363 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52364 if (!SWIG_IsOK(res2)) {
52365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52366 }
52367 arg2 = reinterpret_cast< wxWindow * >(argp2);
52368 {
52369 PyThreadState* __tstate = wxPyBeginAllowThreads();
52370 result = (arg1)->GetItemSpan(arg2);
52371 wxPyEndAllowThreads(__tstate);
52372 if (PyErr_Occurred()) SWIG_fail;
52373 }
52374 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52375 return resultobj;
52376 fail:
52377 return NULL;
52378 }
52379
52380
52381 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52382 PyObject *resultobj = 0;
52383 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52384 wxSizer *arg2 = (wxSizer *) 0 ;
52385 wxGBSpan result;
52386 void *argp1 = 0 ;
52387 int res1 = 0 ;
52388 void *argp2 = 0 ;
52389 int res2 = 0 ;
52390
52391 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52395 }
52396 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52397 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52398 if (!SWIG_IsOK(res2)) {
52399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52400 }
52401 arg2 = reinterpret_cast< wxSizer * >(argp2);
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 result = (arg1)->GetItemSpan(arg2);
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52409 return resultobj;
52410 fail:
52411 return NULL;
52412 }
52413
52414
52415 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52416 PyObject *resultobj = 0;
52417 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52418 size_t arg2 ;
52419 wxGBSpan result;
52420 void *argp1 = 0 ;
52421 int res1 = 0 ;
52422 size_t val2 ;
52423 int ecode2 = 0 ;
52424
52425 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52427 if (!SWIG_IsOK(res1)) {
52428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52429 }
52430 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52431 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52432 if (!SWIG_IsOK(ecode2)) {
52433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52434 }
52435 arg2 = static_cast< size_t >(val2);
52436 {
52437 PyThreadState* __tstate = wxPyBeginAllowThreads();
52438 result = (arg1)->GetItemSpan(arg2);
52439 wxPyEndAllowThreads(__tstate);
52440 if (PyErr_Occurred()) SWIG_fail;
52441 }
52442 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52443 return resultobj;
52444 fail:
52445 return NULL;
52446 }
52447
52448
52449 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52450 int argc;
52451 PyObject *argv[3];
52452
52453 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52454 --argc;
52455 if (argc == 2) {
52456 int _v = 0;
52457 {
52458 void *vptr = 0;
52459 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52460 _v = SWIG_CheckState(res);
52461 }
52462 if (!_v) goto check_1;
52463 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52464 }
52465 check_1:
52466
52467 if (argc == 2) {
52468 int _v = 0;
52469 {
52470 void *vptr = 0;
52471 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52472 _v = SWIG_CheckState(res);
52473 }
52474 if (!_v) goto check_2;
52475 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52476 }
52477 check_2:
52478
52479 if (argc == 2) {
52480 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52481 }
52482
52483 fail:
52484 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52485 return NULL;
52486 }
52487
52488
52489 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52490 PyObject *resultobj = 0;
52491 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52492 wxWindow *arg2 = (wxWindow *) 0 ;
52493 wxGBSpan *arg3 = 0 ;
52494 bool result;
52495 void *argp1 = 0 ;
52496 int res1 = 0 ;
52497 void *argp2 = 0 ;
52498 int res2 = 0 ;
52499 wxGBSpan temp3 ;
52500
52501 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52503 if (!SWIG_IsOK(res1)) {
52504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52505 }
52506 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52507 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52508 if (!SWIG_IsOK(res2)) {
52509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52510 }
52511 arg2 = reinterpret_cast< wxWindow * >(argp2);
52512 {
52513 arg3 = &temp3;
52514 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52515 }
52516 {
52517 PyThreadState* __tstate = wxPyBeginAllowThreads();
52518 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52519 wxPyEndAllowThreads(__tstate);
52520 if (PyErr_Occurred()) SWIG_fail;
52521 }
52522 {
52523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52524 }
52525 return resultobj;
52526 fail:
52527 return NULL;
52528 }
52529
52530
52531 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52532 PyObject *resultobj = 0;
52533 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52534 wxSizer *arg2 = (wxSizer *) 0 ;
52535 wxGBSpan *arg3 = 0 ;
52536 bool result;
52537 void *argp1 = 0 ;
52538 int res1 = 0 ;
52539 void *argp2 = 0 ;
52540 int res2 = 0 ;
52541 wxGBSpan temp3 ;
52542
52543 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52545 if (!SWIG_IsOK(res1)) {
52546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52547 }
52548 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52549 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52550 if (!SWIG_IsOK(res2)) {
52551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52552 }
52553 arg2 = reinterpret_cast< wxSizer * >(argp2);
52554 {
52555 arg3 = &temp3;
52556 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52557 }
52558 {
52559 PyThreadState* __tstate = wxPyBeginAllowThreads();
52560 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52561 wxPyEndAllowThreads(__tstate);
52562 if (PyErr_Occurred()) SWIG_fail;
52563 }
52564 {
52565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52566 }
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52574 PyObject *resultobj = 0;
52575 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52576 size_t arg2 ;
52577 wxGBSpan *arg3 = 0 ;
52578 bool result;
52579 void *argp1 = 0 ;
52580 int res1 = 0 ;
52581 size_t val2 ;
52582 int ecode2 = 0 ;
52583 wxGBSpan temp3 ;
52584
52585 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52587 if (!SWIG_IsOK(res1)) {
52588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52589 }
52590 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52591 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52592 if (!SWIG_IsOK(ecode2)) {
52593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52594 }
52595 arg2 = static_cast< size_t >(val2);
52596 {
52597 arg3 = &temp3;
52598 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52599 }
52600 {
52601 PyThreadState* __tstate = wxPyBeginAllowThreads();
52602 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52603 wxPyEndAllowThreads(__tstate);
52604 if (PyErr_Occurred()) SWIG_fail;
52605 }
52606 {
52607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52608 }
52609 return resultobj;
52610 fail:
52611 return NULL;
52612 }
52613
52614
52615 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52616 int argc;
52617 PyObject *argv[4];
52618
52619 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52620 --argc;
52621 if (argc == 3) {
52622 int _v = 0;
52623 {
52624 void *vptr = 0;
52625 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52626 _v = SWIG_CheckState(res);
52627 }
52628 if (!_v) goto check_1;
52629 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52630 }
52631 check_1:
52632
52633 if (argc == 3) {
52634 int _v = 0;
52635 {
52636 void *vptr = 0;
52637 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52638 _v = SWIG_CheckState(res);
52639 }
52640 if (!_v) goto check_2;
52641 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52642 }
52643 check_2:
52644
52645 if (argc == 3) {
52646 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52647 }
52648
52649 fail:
52650 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52656 PyObject *resultobj = 0;
52657 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52658 wxWindow *arg2 = (wxWindow *) 0 ;
52659 wxGBSizerItem *result = 0 ;
52660 void *argp1 = 0 ;
52661 int res1 = 0 ;
52662 void *argp2 = 0 ;
52663 int res2 = 0 ;
52664
52665 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52667 if (!SWIG_IsOK(res1)) {
52668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52669 }
52670 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52671 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52672 if (!SWIG_IsOK(res2)) {
52673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52674 }
52675 arg2 = reinterpret_cast< wxWindow * >(argp2);
52676 {
52677 PyThreadState* __tstate = wxPyBeginAllowThreads();
52678 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52679 wxPyEndAllowThreads(__tstate);
52680 if (PyErr_Occurred()) SWIG_fail;
52681 }
52682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52683 return resultobj;
52684 fail:
52685 return NULL;
52686 }
52687
52688
52689 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52690 PyObject *resultobj = 0;
52691 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52692 wxSizer *arg2 = (wxSizer *) 0 ;
52693 wxGBSizerItem *result = 0 ;
52694 void *argp1 = 0 ;
52695 int res1 = 0 ;
52696 void *argp2 = 0 ;
52697 int res2 = 0 ;
52698
52699 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52701 if (!SWIG_IsOK(res1)) {
52702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52703 }
52704 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52705 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52706 if (!SWIG_IsOK(res2)) {
52707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52708 }
52709 arg2 = reinterpret_cast< wxSizer * >(argp2);
52710 {
52711 PyThreadState* __tstate = wxPyBeginAllowThreads();
52712 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52713 wxPyEndAllowThreads(__tstate);
52714 if (PyErr_Occurred()) SWIG_fail;
52715 }
52716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52717 return resultobj;
52718 fail:
52719 return NULL;
52720 }
52721
52722
52723 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52724 int argc;
52725 PyObject *argv[3];
52726
52727 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52728 --argc;
52729 if (argc == 2) {
52730 int _v = 0;
52731 {
52732 void *vptr = 0;
52733 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52734 _v = SWIG_CheckState(res);
52735 }
52736 if (!_v) goto check_1;
52737 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52738 }
52739 check_1:
52740
52741 if (argc == 2) {
52742 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52743 }
52744
52745 fail:
52746 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52747 return NULL;
52748 }
52749
52750
52751 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52752 PyObject *resultobj = 0;
52753 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52754 wxGBPosition *arg2 = 0 ;
52755 wxGBSizerItem *result = 0 ;
52756 void *argp1 = 0 ;
52757 int res1 = 0 ;
52758 wxGBPosition temp2 ;
52759 PyObject * obj0 = 0 ;
52760 PyObject * obj1 = 0 ;
52761 char * kwnames[] = {
52762 (char *) "self",(char *) "pos", NULL
52763 };
52764
52765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52767 if (!SWIG_IsOK(res1)) {
52768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52769 }
52770 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52771 {
52772 arg2 = &temp2;
52773 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52774 }
52775 {
52776 PyThreadState* __tstate = wxPyBeginAllowThreads();
52777 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52778 wxPyEndAllowThreads(__tstate);
52779 if (PyErr_Occurred()) SWIG_fail;
52780 }
52781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52782 return resultobj;
52783 fail:
52784 return NULL;
52785 }
52786
52787
52788 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52789 PyObject *resultobj = 0;
52790 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52791 wxPoint *arg2 = 0 ;
52792 wxGBSizerItem *result = 0 ;
52793 void *argp1 = 0 ;
52794 int res1 = 0 ;
52795 wxPoint temp2 ;
52796 PyObject * obj0 = 0 ;
52797 PyObject * obj1 = 0 ;
52798 char * kwnames[] = {
52799 (char *) "self",(char *) "pt", NULL
52800 };
52801
52802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52804 if (!SWIG_IsOK(res1)) {
52805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52806 }
52807 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52808 {
52809 arg2 = &temp2;
52810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52811 }
52812 {
52813 PyThreadState* __tstate = wxPyBeginAllowThreads();
52814 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52815 wxPyEndAllowThreads(__tstate);
52816 if (PyErr_Occurred()) SWIG_fail;
52817 }
52818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52819 return resultobj;
52820 fail:
52821 return NULL;
52822 }
52823
52824
52825 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52826 PyObject *resultobj = 0;
52827 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52828 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52829 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52830 bool result;
52831 void *argp1 = 0 ;
52832 int res1 = 0 ;
52833 void *argp2 = 0 ;
52834 int res2 = 0 ;
52835 void *argp3 = 0 ;
52836 int res3 = 0 ;
52837 PyObject * obj0 = 0 ;
52838 PyObject * obj1 = 0 ;
52839 PyObject * obj2 = 0 ;
52840 char * kwnames[] = {
52841 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52842 };
52843
52844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52846 if (!SWIG_IsOK(res1)) {
52847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52848 }
52849 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52851 if (!SWIG_IsOK(res2)) {
52852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52853 }
52854 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52855 if (obj2) {
52856 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52857 if (!SWIG_IsOK(res3)) {
52858 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52859 }
52860 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52861 }
52862 {
52863 PyThreadState* __tstate = wxPyBeginAllowThreads();
52864 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52865 wxPyEndAllowThreads(__tstate);
52866 if (PyErr_Occurred()) SWIG_fail;
52867 }
52868 {
52869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52870 }
52871 return resultobj;
52872 fail:
52873 return NULL;
52874 }
52875
52876
52877 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52878 PyObject *resultobj = 0;
52879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52880 wxGBPosition *arg2 = 0 ;
52881 wxGBSpan *arg3 = 0 ;
52882 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52883 bool result;
52884 void *argp1 = 0 ;
52885 int res1 = 0 ;
52886 wxGBPosition temp2 ;
52887 wxGBSpan temp3 ;
52888 void *argp4 = 0 ;
52889 int res4 = 0 ;
52890 PyObject * obj0 = 0 ;
52891 PyObject * obj1 = 0 ;
52892 PyObject * obj2 = 0 ;
52893 PyObject * obj3 = 0 ;
52894 char * kwnames[] = {
52895 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52896 };
52897
52898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52900 if (!SWIG_IsOK(res1)) {
52901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52902 }
52903 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52904 {
52905 arg2 = &temp2;
52906 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52907 }
52908 {
52909 arg3 = &temp3;
52910 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52911 }
52912 if (obj3) {
52913 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52914 if (!SWIG_IsOK(res4)) {
52915 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52916 }
52917 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52918 }
52919 {
52920 PyThreadState* __tstate = wxPyBeginAllowThreads();
52921 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52922 wxPyEndAllowThreads(__tstate);
52923 if (PyErr_Occurred()) SWIG_fail;
52924 }
52925 {
52926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52927 }
52928 return resultobj;
52929 fail:
52930 return NULL;
52931 }
52932
52933
52934 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52935 PyObject *obj;
52936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52937 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52938 return SWIG_Py_Void();
52939 }
52940
52941 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52942 return SWIG_Python_InitShadowInstance(args);
52943 }
52944
52945 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52946 PyObject *resultobj = 0;
52947 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52948 wxRelationship arg2 ;
52949 wxWindow *arg3 = (wxWindow *) 0 ;
52950 wxEdge arg4 ;
52951 int arg5 = (int) 0 ;
52952 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52953 void *argp1 = 0 ;
52954 int res1 = 0 ;
52955 int val2 ;
52956 int ecode2 = 0 ;
52957 void *argp3 = 0 ;
52958 int res3 = 0 ;
52959 int val4 ;
52960 int ecode4 = 0 ;
52961 int val5 ;
52962 int ecode5 = 0 ;
52963 int val6 ;
52964 int ecode6 = 0 ;
52965 PyObject * obj0 = 0 ;
52966 PyObject * obj1 = 0 ;
52967 PyObject * obj2 = 0 ;
52968 PyObject * obj3 = 0 ;
52969 PyObject * obj4 = 0 ;
52970 PyObject * obj5 = 0 ;
52971 char * kwnames[] = {
52972 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52973 };
52974
52975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52977 if (!SWIG_IsOK(res1)) {
52978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52979 }
52980 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52981 ecode2 = SWIG_AsVal_int(obj1, &val2);
52982 if (!SWIG_IsOK(ecode2)) {
52983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52984 }
52985 arg2 = static_cast< wxRelationship >(val2);
52986 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52987 if (!SWIG_IsOK(res3)) {
52988 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52989 }
52990 arg3 = reinterpret_cast< wxWindow * >(argp3);
52991 ecode4 = SWIG_AsVal_int(obj3, &val4);
52992 if (!SWIG_IsOK(ecode4)) {
52993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52994 }
52995 arg4 = static_cast< wxEdge >(val4);
52996 if (obj4) {
52997 ecode5 = SWIG_AsVal_int(obj4, &val5);
52998 if (!SWIG_IsOK(ecode5)) {
52999 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
53000 }
53001 arg5 = static_cast< int >(val5);
53002 }
53003 if (obj5) {
53004 ecode6 = SWIG_AsVal_int(obj5, &val6);
53005 if (!SWIG_IsOK(ecode6)) {
53006 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
53007 }
53008 arg6 = static_cast< int >(val6);
53009 }
53010 {
53011 PyThreadState* __tstate = wxPyBeginAllowThreads();
53012 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
53013 wxPyEndAllowThreads(__tstate);
53014 if (PyErr_Occurred()) SWIG_fail;
53015 }
53016 resultobj = SWIG_Py_Void();
53017 return resultobj;
53018 fail:
53019 return NULL;
53020 }
53021
53022
53023 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53024 PyObject *resultobj = 0;
53025 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53026 wxWindow *arg2 = (wxWindow *) 0 ;
53027 int arg3 = (int) 0 ;
53028 void *argp1 = 0 ;
53029 int res1 = 0 ;
53030 void *argp2 = 0 ;
53031 int res2 = 0 ;
53032 int val3 ;
53033 int ecode3 = 0 ;
53034 PyObject * obj0 = 0 ;
53035 PyObject * obj1 = 0 ;
53036 PyObject * obj2 = 0 ;
53037 char * kwnames[] = {
53038 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53039 };
53040
53041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53043 if (!SWIG_IsOK(res1)) {
53044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53045 }
53046 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53047 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53048 if (!SWIG_IsOK(res2)) {
53049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53050 }
53051 arg2 = reinterpret_cast< wxWindow * >(argp2);
53052 if (obj2) {
53053 ecode3 = SWIG_AsVal_int(obj2, &val3);
53054 if (!SWIG_IsOK(ecode3)) {
53055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53056 }
53057 arg3 = static_cast< int >(val3);
53058 }
53059 {
53060 PyThreadState* __tstate = wxPyBeginAllowThreads();
53061 (arg1)->LeftOf(arg2,arg3);
53062 wxPyEndAllowThreads(__tstate);
53063 if (PyErr_Occurred()) SWIG_fail;
53064 }
53065 resultobj = SWIG_Py_Void();
53066 return resultobj;
53067 fail:
53068 return NULL;
53069 }
53070
53071
53072 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53073 PyObject *resultobj = 0;
53074 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53075 wxWindow *arg2 = (wxWindow *) 0 ;
53076 int arg3 = (int) 0 ;
53077 void *argp1 = 0 ;
53078 int res1 = 0 ;
53079 void *argp2 = 0 ;
53080 int res2 = 0 ;
53081 int val3 ;
53082 int ecode3 = 0 ;
53083 PyObject * obj0 = 0 ;
53084 PyObject * obj1 = 0 ;
53085 PyObject * obj2 = 0 ;
53086 char * kwnames[] = {
53087 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53088 };
53089
53090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53092 if (!SWIG_IsOK(res1)) {
53093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53094 }
53095 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53097 if (!SWIG_IsOK(res2)) {
53098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53099 }
53100 arg2 = reinterpret_cast< wxWindow * >(argp2);
53101 if (obj2) {
53102 ecode3 = SWIG_AsVal_int(obj2, &val3);
53103 if (!SWIG_IsOK(ecode3)) {
53104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53105 }
53106 arg3 = static_cast< int >(val3);
53107 }
53108 {
53109 PyThreadState* __tstate = wxPyBeginAllowThreads();
53110 (arg1)->RightOf(arg2,arg3);
53111 wxPyEndAllowThreads(__tstate);
53112 if (PyErr_Occurred()) SWIG_fail;
53113 }
53114 resultobj = SWIG_Py_Void();
53115 return resultobj;
53116 fail:
53117 return NULL;
53118 }
53119
53120
53121 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53122 PyObject *resultobj = 0;
53123 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53124 wxWindow *arg2 = (wxWindow *) 0 ;
53125 int arg3 = (int) 0 ;
53126 void *argp1 = 0 ;
53127 int res1 = 0 ;
53128 void *argp2 = 0 ;
53129 int res2 = 0 ;
53130 int val3 ;
53131 int ecode3 = 0 ;
53132 PyObject * obj0 = 0 ;
53133 PyObject * obj1 = 0 ;
53134 PyObject * obj2 = 0 ;
53135 char * kwnames[] = {
53136 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53137 };
53138
53139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53141 if (!SWIG_IsOK(res1)) {
53142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53143 }
53144 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53146 if (!SWIG_IsOK(res2)) {
53147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53148 }
53149 arg2 = reinterpret_cast< wxWindow * >(argp2);
53150 if (obj2) {
53151 ecode3 = SWIG_AsVal_int(obj2, &val3);
53152 if (!SWIG_IsOK(ecode3)) {
53153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53154 }
53155 arg3 = static_cast< int >(val3);
53156 }
53157 {
53158 PyThreadState* __tstate = wxPyBeginAllowThreads();
53159 (arg1)->Above(arg2,arg3);
53160 wxPyEndAllowThreads(__tstate);
53161 if (PyErr_Occurred()) SWIG_fail;
53162 }
53163 resultobj = SWIG_Py_Void();
53164 return resultobj;
53165 fail:
53166 return NULL;
53167 }
53168
53169
53170 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53171 PyObject *resultobj = 0;
53172 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53173 wxWindow *arg2 = (wxWindow *) 0 ;
53174 int arg3 = (int) 0 ;
53175 void *argp1 = 0 ;
53176 int res1 = 0 ;
53177 void *argp2 = 0 ;
53178 int res2 = 0 ;
53179 int val3 ;
53180 int ecode3 = 0 ;
53181 PyObject * obj0 = 0 ;
53182 PyObject * obj1 = 0 ;
53183 PyObject * obj2 = 0 ;
53184 char * kwnames[] = {
53185 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53186 };
53187
53188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53190 if (!SWIG_IsOK(res1)) {
53191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53192 }
53193 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53195 if (!SWIG_IsOK(res2)) {
53196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53197 }
53198 arg2 = reinterpret_cast< wxWindow * >(argp2);
53199 if (obj2) {
53200 ecode3 = SWIG_AsVal_int(obj2, &val3);
53201 if (!SWIG_IsOK(ecode3)) {
53202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53203 }
53204 arg3 = static_cast< int >(val3);
53205 }
53206 {
53207 PyThreadState* __tstate = wxPyBeginAllowThreads();
53208 (arg1)->Below(arg2,arg3);
53209 wxPyEndAllowThreads(__tstate);
53210 if (PyErr_Occurred()) SWIG_fail;
53211 }
53212 resultobj = SWIG_Py_Void();
53213 return resultobj;
53214 fail:
53215 return NULL;
53216 }
53217
53218
53219 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53220 PyObject *resultobj = 0;
53221 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53222 wxWindow *arg2 = (wxWindow *) 0 ;
53223 wxEdge arg3 ;
53224 int arg4 = (int) 0 ;
53225 void *argp1 = 0 ;
53226 int res1 = 0 ;
53227 void *argp2 = 0 ;
53228 int res2 = 0 ;
53229 int val3 ;
53230 int ecode3 = 0 ;
53231 int val4 ;
53232 int ecode4 = 0 ;
53233 PyObject * obj0 = 0 ;
53234 PyObject * obj1 = 0 ;
53235 PyObject * obj2 = 0 ;
53236 PyObject * obj3 = 0 ;
53237 char * kwnames[] = {
53238 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53239 };
53240
53241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53243 if (!SWIG_IsOK(res1)) {
53244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53245 }
53246 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53248 if (!SWIG_IsOK(res2)) {
53249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53250 }
53251 arg2 = reinterpret_cast< wxWindow * >(argp2);
53252 ecode3 = SWIG_AsVal_int(obj2, &val3);
53253 if (!SWIG_IsOK(ecode3)) {
53254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53255 }
53256 arg3 = static_cast< wxEdge >(val3);
53257 if (obj3) {
53258 ecode4 = SWIG_AsVal_int(obj3, &val4);
53259 if (!SWIG_IsOK(ecode4)) {
53260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53261 }
53262 arg4 = static_cast< int >(val4);
53263 }
53264 {
53265 PyThreadState* __tstate = wxPyBeginAllowThreads();
53266 (arg1)->SameAs(arg2,arg3,arg4);
53267 wxPyEndAllowThreads(__tstate);
53268 if (PyErr_Occurred()) SWIG_fail;
53269 }
53270 resultobj = SWIG_Py_Void();
53271 return resultobj;
53272 fail:
53273 return NULL;
53274 }
53275
53276
53277 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53278 PyObject *resultobj = 0;
53279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53280 wxWindow *arg2 = (wxWindow *) 0 ;
53281 wxEdge arg3 ;
53282 int arg4 ;
53283 void *argp1 = 0 ;
53284 int res1 = 0 ;
53285 void *argp2 = 0 ;
53286 int res2 = 0 ;
53287 int val3 ;
53288 int ecode3 = 0 ;
53289 int val4 ;
53290 int ecode4 = 0 ;
53291 PyObject * obj0 = 0 ;
53292 PyObject * obj1 = 0 ;
53293 PyObject * obj2 = 0 ;
53294 PyObject * obj3 = 0 ;
53295 char * kwnames[] = {
53296 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53297 };
53298
53299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53301 if (!SWIG_IsOK(res1)) {
53302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53303 }
53304 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53306 if (!SWIG_IsOK(res2)) {
53307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53308 }
53309 arg2 = reinterpret_cast< wxWindow * >(argp2);
53310 ecode3 = SWIG_AsVal_int(obj2, &val3);
53311 if (!SWIG_IsOK(ecode3)) {
53312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53313 }
53314 arg3 = static_cast< wxEdge >(val3);
53315 ecode4 = SWIG_AsVal_int(obj3, &val4);
53316 if (!SWIG_IsOK(ecode4)) {
53317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53318 }
53319 arg4 = static_cast< int >(val4);
53320 {
53321 PyThreadState* __tstate = wxPyBeginAllowThreads();
53322 (arg1)->PercentOf(arg2,arg3,arg4);
53323 wxPyEndAllowThreads(__tstate);
53324 if (PyErr_Occurred()) SWIG_fail;
53325 }
53326 resultobj = SWIG_Py_Void();
53327 return resultobj;
53328 fail:
53329 return NULL;
53330 }
53331
53332
53333 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53334 PyObject *resultobj = 0;
53335 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53336 int arg2 ;
53337 void *argp1 = 0 ;
53338 int res1 = 0 ;
53339 int val2 ;
53340 int ecode2 = 0 ;
53341 PyObject * obj0 = 0 ;
53342 PyObject * obj1 = 0 ;
53343 char * kwnames[] = {
53344 (char *) "self",(char *) "val", NULL
53345 };
53346
53347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53349 if (!SWIG_IsOK(res1)) {
53350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53351 }
53352 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53353 ecode2 = SWIG_AsVal_int(obj1, &val2);
53354 if (!SWIG_IsOK(ecode2)) {
53355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53356 }
53357 arg2 = static_cast< int >(val2);
53358 {
53359 PyThreadState* __tstate = wxPyBeginAllowThreads();
53360 (arg1)->Absolute(arg2);
53361 wxPyEndAllowThreads(__tstate);
53362 if (PyErr_Occurred()) SWIG_fail;
53363 }
53364 resultobj = SWIG_Py_Void();
53365 return resultobj;
53366 fail:
53367 return NULL;
53368 }
53369
53370
53371 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53372 PyObject *resultobj = 0;
53373 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53374 void *argp1 = 0 ;
53375 int res1 = 0 ;
53376 PyObject *swig_obj[1] ;
53377
53378 if (!args) SWIG_fail;
53379 swig_obj[0] = args;
53380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53381 if (!SWIG_IsOK(res1)) {
53382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53383 }
53384 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53385 {
53386 PyThreadState* __tstate = wxPyBeginAllowThreads();
53387 (arg1)->Unconstrained();
53388 wxPyEndAllowThreads(__tstate);
53389 if (PyErr_Occurred()) SWIG_fail;
53390 }
53391 resultobj = SWIG_Py_Void();
53392 return resultobj;
53393 fail:
53394 return NULL;
53395 }
53396
53397
53398 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53399 PyObject *resultobj = 0;
53400 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53401 void *argp1 = 0 ;
53402 int res1 = 0 ;
53403 PyObject *swig_obj[1] ;
53404
53405 if (!args) SWIG_fail;
53406 swig_obj[0] = args;
53407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53408 if (!SWIG_IsOK(res1)) {
53409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53410 }
53411 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53412 {
53413 PyThreadState* __tstate = wxPyBeginAllowThreads();
53414 (arg1)->AsIs();
53415 wxPyEndAllowThreads(__tstate);
53416 if (PyErr_Occurred()) SWIG_fail;
53417 }
53418 resultobj = SWIG_Py_Void();
53419 return resultobj;
53420 fail:
53421 return NULL;
53422 }
53423
53424
53425 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53426 PyObject *resultobj = 0;
53427 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53428 wxWindow *result = 0 ;
53429 void *argp1 = 0 ;
53430 int res1 = 0 ;
53431 PyObject *swig_obj[1] ;
53432
53433 if (!args) SWIG_fail;
53434 swig_obj[0] = args;
53435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53436 if (!SWIG_IsOK(res1)) {
53437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53438 }
53439 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53440 {
53441 PyThreadState* __tstate = wxPyBeginAllowThreads();
53442 result = (wxWindow *)(arg1)->GetOtherWindow();
53443 wxPyEndAllowThreads(__tstate);
53444 if (PyErr_Occurred()) SWIG_fail;
53445 }
53446 {
53447 resultobj = wxPyMake_wxObject(result, 0);
53448 }
53449 return resultobj;
53450 fail:
53451 return NULL;
53452 }
53453
53454
53455 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53456 PyObject *resultobj = 0;
53457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53458 wxEdge result;
53459 void *argp1 = 0 ;
53460 int res1 = 0 ;
53461 PyObject *swig_obj[1] ;
53462
53463 if (!args) SWIG_fail;
53464 swig_obj[0] = args;
53465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53466 if (!SWIG_IsOK(res1)) {
53467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53468 }
53469 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53470 {
53471 PyThreadState* __tstate = wxPyBeginAllowThreads();
53472 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53473 wxPyEndAllowThreads(__tstate);
53474 if (PyErr_Occurred()) SWIG_fail;
53475 }
53476 resultobj = SWIG_From_int(static_cast< int >(result));
53477 return resultobj;
53478 fail:
53479 return NULL;
53480 }
53481
53482
53483 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53484 PyObject *resultobj = 0;
53485 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53486 wxEdge arg2 ;
53487 void *argp1 = 0 ;
53488 int res1 = 0 ;
53489 int val2 ;
53490 int ecode2 = 0 ;
53491 PyObject * obj0 = 0 ;
53492 PyObject * obj1 = 0 ;
53493 char * kwnames[] = {
53494 (char *) "self",(char *) "which", NULL
53495 };
53496
53497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53499 if (!SWIG_IsOK(res1)) {
53500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53501 }
53502 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53503 ecode2 = SWIG_AsVal_int(obj1, &val2);
53504 if (!SWIG_IsOK(ecode2)) {
53505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53506 }
53507 arg2 = static_cast< wxEdge >(val2);
53508 {
53509 PyThreadState* __tstate = wxPyBeginAllowThreads();
53510 (arg1)->SetEdge(arg2);
53511 wxPyEndAllowThreads(__tstate);
53512 if (PyErr_Occurred()) SWIG_fail;
53513 }
53514 resultobj = SWIG_Py_Void();
53515 return resultobj;
53516 fail:
53517 return NULL;
53518 }
53519
53520
53521 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53522 PyObject *resultobj = 0;
53523 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53524 int arg2 ;
53525 void *argp1 = 0 ;
53526 int res1 = 0 ;
53527 int val2 ;
53528 int ecode2 = 0 ;
53529 PyObject * obj0 = 0 ;
53530 PyObject * obj1 = 0 ;
53531 char * kwnames[] = {
53532 (char *) "self",(char *) "v", NULL
53533 };
53534
53535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53537 if (!SWIG_IsOK(res1)) {
53538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53539 }
53540 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53541 ecode2 = SWIG_AsVal_int(obj1, &val2);
53542 if (!SWIG_IsOK(ecode2)) {
53543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53544 }
53545 arg2 = static_cast< int >(val2);
53546 {
53547 PyThreadState* __tstate = wxPyBeginAllowThreads();
53548 (arg1)->SetValue(arg2);
53549 wxPyEndAllowThreads(__tstate);
53550 if (PyErr_Occurred()) SWIG_fail;
53551 }
53552 resultobj = SWIG_Py_Void();
53553 return resultobj;
53554 fail:
53555 return NULL;
53556 }
53557
53558
53559 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53560 PyObject *resultobj = 0;
53561 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53562 int result;
53563 void *argp1 = 0 ;
53564 int res1 = 0 ;
53565 PyObject *swig_obj[1] ;
53566
53567 if (!args) SWIG_fail;
53568 swig_obj[0] = args;
53569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53570 if (!SWIG_IsOK(res1)) {
53571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53572 }
53573 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53574 {
53575 PyThreadState* __tstate = wxPyBeginAllowThreads();
53576 result = (int)(arg1)->GetMargin();
53577 wxPyEndAllowThreads(__tstate);
53578 if (PyErr_Occurred()) SWIG_fail;
53579 }
53580 resultobj = SWIG_From_int(static_cast< int >(result));
53581 return resultobj;
53582 fail:
53583 return NULL;
53584 }
53585
53586
53587 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53588 PyObject *resultobj = 0;
53589 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53590 int arg2 ;
53591 void *argp1 = 0 ;
53592 int res1 = 0 ;
53593 int val2 ;
53594 int ecode2 = 0 ;
53595 PyObject * obj0 = 0 ;
53596 PyObject * obj1 = 0 ;
53597 char * kwnames[] = {
53598 (char *) "self",(char *) "m", NULL
53599 };
53600
53601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53603 if (!SWIG_IsOK(res1)) {
53604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53605 }
53606 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53607 ecode2 = SWIG_AsVal_int(obj1, &val2);
53608 if (!SWIG_IsOK(ecode2)) {
53609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53610 }
53611 arg2 = static_cast< int >(val2);
53612 {
53613 PyThreadState* __tstate = wxPyBeginAllowThreads();
53614 (arg1)->SetMargin(arg2);
53615 wxPyEndAllowThreads(__tstate);
53616 if (PyErr_Occurred()) SWIG_fail;
53617 }
53618 resultobj = SWIG_Py_Void();
53619 return resultobj;
53620 fail:
53621 return NULL;
53622 }
53623
53624
53625 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53626 PyObject *resultobj = 0;
53627 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53628 int result;
53629 void *argp1 = 0 ;
53630 int res1 = 0 ;
53631 PyObject *swig_obj[1] ;
53632
53633 if (!args) SWIG_fail;
53634 swig_obj[0] = args;
53635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53636 if (!SWIG_IsOK(res1)) {
53637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53638 }
53639 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53640 {
53641 PyThreadState* __tstate = wxPyBeginAllowThreads();
53642 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53643 wxPyEndAllowThreads(__tstate);
53644 if (PyErr_Occurred()) SWIG_fail;
53645 }
53646 resultobj = SWIG_From_int(static_cast< int >(result));
53647 return resultobj;
53648 fail:
53649 return NULL;
53650 }
53651
53652
53653 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53654 PyObject *resultobj = 0;
53655 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53656 int result;
53657 void *argp1 = 0 ;
53658 int res1 = 0 ;
53659 PyObject *swig_obj[1] ;
53660
53661 if (!args) SWIG_fail;
53662 swig_obj[0] = args;
53663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53664 if (!SWIG_IsOK(res1)) {
53665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53666 }
53667 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53668 {
53669 PyThreadState* __tstate = wxPyBeginAllowThreads();
53670 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53671 wxPyEndAllowThreads(__tstate);
53672 if (PyErr_Occurred()) SWIG_fail;
53673 }
53674 resultobj = SWIG_From_int(static_cast< int >(result));
53675 return resultobj;
53676 fail:
53677 return NULL;
53678 }
53679
53680
53681 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53682 PyObject *resultobj = 0;
53683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53684 int result;
53685 void *argp1 = 0 ;
53686 int res1 = 0 ;
53687 PyObject *swig_obj[1] ;
53688
53689 if (!args) SWIG_fail;
53690 swig_obj[0] = args;
53691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53692 if (!SWIG_IsOK(res1)) {
53693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53694 }
53695 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 resultobj = SWIG_From_int(static_cast< int >(result));
53703 return resultobj;
53704 fail:
53705 return NULL;
53706 }
53707
53708
53709 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53710 PyObject *resultobj = 0;
53711 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53712 bool result;
53713 void *argp1 = 0 ;
53714 int res1 = 0 ;
53715 PyObject *swig_obj[1] ;
53716
53717 if (!args) SWIG_fail;
53718 swig_obj[0] = args;
53719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53720 if (!SWIG_IsOK(res1)) {
53721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53722 }
53723 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53724 {
53725 PyThreadState* __tstate = wxPyBeginAllowThreads();
53726 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53727 wxPyEndAllowThreads(__tstate);
53728 if (PyErr_Occurred()) SWIG_fail;
53729 }
53730 {
53731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53732 }
53733 return resultobj;
53734 fail:
53735 return NULL;
53736 }
53737
53738
53739 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53740 PyObject *resultobj = 0;
53741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53742 bool arg2 ;
53743 void *argp1 = 0 ;
53744 int res1 = 0 ;
53745 bool val2 ;
53746 int ecode2 = 0 ;
53747 PyObject * obj0 = 0 ;
53748 PyObject * obj1 = 0 ;
53749 char * kwnames[] = {
53750 (char *) "self",(char *) "d", NULL
53751 };
53752
53753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53755 if (!SWIG_IsOK(res1)) {
53756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53757 }
53758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53760 if (!SWIG_IsOK(ecode2)) {
53761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53762 }
53763 arg2 = static_cast< bool >(val2);
53764 {
53765 PyThreadState* __tstate = wxPyBeginAllowThreads();
53766 (arg1)->SetDone(arg2);
53767 wxPyEndAllowThreads(__tstate);
53768 if (PyErr_Occurred()) SWIG_fail;
53769 }
53770 resultobj = SWIG_Py_Void();
53771 return resultobj;
53772 fail:
53773 return NULL;
53774 }
53775
53776
53777 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53778 PyObject *resultobj = 0;
53779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53780 wxRelationship result;
53781 void *argp1 = 0 ;
53782 int res1 = 0 ;
53783 PyObject *swig_obj[1] ;
53784
53785 if (!args) SWIG_fail;
53786 swig_obj[0] = args;
53787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53788 if (!SWIG_IsOK(res1)) {
53789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53790 }
53791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53792 {
53793 PyThreadState* __tstate = wxPyBeginAllowThreads();
53794 result = (wxRelationship)(arg1)->GetRelationship();
53795 wxPyEndAllowThreads(__tstate);
53796 if (PyErr_Occurred()) SWIG_fail;
53797 }
53798 resultobj = SWIG_From_int(static_cast< int >(result));
53799 return resultobj;
53800 fail:
53801 return NULL;
53802 }
53803
53804
53805 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53806 PyObject *resultobj = 0;
53807 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53808 wxRelationship arg2 ;
53809 void *argp1 = 0 ;
53810 int res1 = 0 ;
53811 int val2 ;
53812 int ecode2 = 0 ;
53813 PyObject * obj0 = 0 ;
53814 PyObject * obj1 = 0 ;
53815 char * kwnames[] = {
53816 (char *) "self",(char *) "r", NULL
53817 };
53818
53819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53821 if (!SWIG_IsOK(res1)) {
53822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53823 }
53824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53825 ecode2 = SWIG_AsVal_int(obj1, &val2);
53826 if (!SWIG_IsOK(ecode2)) {
53827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53828 }
53829 arg2 = static_cast< wxRelationship >(val2);
53830 {
53831 PyThreadState* __tstate = wxPyBeginAllowThreads();
53832 (arg1)->SetRelationship(arg2);
53833 wxPyEndAllowThreads(__tstate);
53834 if (PyErr_Occurred()) SWIG_fail;
53835 }
53836 resultobj = SWIG_Py_Void();
53837 return resultobj;
53838 fail:
53839 return NULL;
53840 }
53841
53842
53843 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53844 PyObject *resultobj = 0;
53845 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53846 wxWindow *arg2 = (wxWindow *) 0 ;
53847 bool result;
53848 void *argp1 = 0 ;
53849 int res1 = 0 ;
53850 void *argp2 = 0 ;
53851 int res2 = 0 ;
53852 PyObject * obj0 = 0 ;
53853 PyObject * obj1 = 0 ;
53854 char * kwnames[] = {
53855 (char *) "self",(char *) "otherW", NULL
53856 };
53857
53858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53860 if (!SWIG_IsOK(res1)) {
53861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53862 }
53863 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53865 if (!SWIG_IsOK(res2)) {
53866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53867 }
53868 arg2 = reinterpret_cast< wxWindow * >(argp2);
53869 {
53870 PyThreadState* __tstate = wxPyBeginAllowThreads();
53871 result = (bool)(arg1)->ResetIfWin(arg2);
53872 wxPyEndAllowThreads(__tstate);
53873 if (PyErr_Occurred()) SWIG_fail;
53874 }
53875 {
53876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53877 }
53878 return resultobj;
53879 fail:
53880 return NULL;
53881 }
53882
53883
53884 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53885 PyObject *resultobj = 0;
53886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53887 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53888 wxWindow *arg3 = (wxWindow *) 0 ;
53889 bool result;
53890 void *argp1 = 0 ;
53891 int res1 = 0 ;
53892 void *argp2 = 0 ;
53893 int res2 = 0 ;
53894 void *argp3 = 0 ;
53895 int res3 = 0 ;
53896 PyObject * obj0 = 0 ;
53897 PyObject * obj1 = 0 ;
53898 PyObject * obj2 = 0 ;
53899 char * kwnames[] = {
53900 (char *) "self",(char *) "constraints",(char *) "win", NULL
53901 };
53902
53903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53905 if (!SWIG_IsOK(res1)) {
53906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53907 }
53908 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53910 if (!SWIG_IsOK(res2)) {
53911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53912 }
53913 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53914 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53915 if (!SWIG_IsOK(res3)) {
53916 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53917 }
53918 arg3 = reinterpret_cast< wxWindow * >(argp3);
53919 {
53920 PyThreadState* __tstate = wxPyBeginAllowThreads();
53921 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53922 wxPyEndAllowThreads(__tstate);
53923 if (PyErr_Occurred()) SWIG_fail;
53924 }
53925 {
53926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53927 }
53928 return resultobj;
53929 fail:
53930 return NULL;
53931 }
53932
53933
53934 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53935 PyObject *resultobj = 0;
53936 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53937 wxEdge arg2 ;
53938 wxWindow *arg3 = (wxWindow *) 0 ;
53939 wxWindow *arg4 = (wxWindow *) 0 ;
53940 int result;
53941 void *argp1 = 0 ;
53942 int res1 = 0 ;
53943 int val2 ;
53944 int ecode2 = 0 ;
53945 void *argp3 = 0 ;
53946 int res3 = 0 ;
53947 void *argp4 = 0 ;
53948 int res4 = 0 ;
53949 PyObject * obj0 = 0 ;
53950 PyObject * obj1 = 0 ;
53951 PyObject * obj2 = 0 ;
53952 PyObject * obj3 = 0 ;
53953 char * kwnames[] = {
53954 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53955 };
53956
53957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53959 if (!SWIG_IsOK(res1)) {
53960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53961 }
53962 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53963 ecode2 = SWIG_AsVal_int(obj1, &val2);
53964 if (!SWIG_IsOK(ecode2)) {
53965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53966 }
53967 arg2 = static_cast< wxEdge >(val2);
53968 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53969 if (!SWIG_IsOK(res3)) {
53970 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53971 }
53972 arg3 = reinterpret_cast< wxWindow * >(argp3);
53973 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53974 if (!SWIG_IsOK(res4)) {
53975 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53976 }
53977 arg4 = reinterpret_cast< wxWindow * >(argp4);
53978 {
53979 PyThreadState* __tstate = wxPyBeginAllowThreads();
53980 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53981 wxPyEndAllowThreads(__tstate);
53982 if (PyErr_Occurred()) SWIG_fail;
53983 }
53984 resultobj = SWIG_From_int(static_cast< int >(result));
53985 return resultobj;
53986 fail:
53987 return NULL;
53988 }
53989
53990
53991 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53992 PyObject *obj;
53993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53994 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53995 return SWIG_Py_Void();
53996 }
53997
53998 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53999 PyObject *resultobj = 0;
54000 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54001 wxIndividualLayoutConstraint *result = 0 ;
54002 void *argp1 = 0 ;
54003 int res1 = 0 ;
54004 PyObject *swig_obj[1] ;
54005
54006 if (!args) SWIG_fail;
54007 swig_obj[0] = args;
54008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54009 if (!SWIG_IsOK(res1)) {
54010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54011 }
54012 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54013 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
54014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54015 return resultobj;
54016 fail:
54017 return NULL;
54018 }
54019
54020
54021 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54022 PyObject *resultobj = 0;
54023 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54024 wxIndividualLayoutConstraint *result = 0 ;
54025 void *argp1 = 0 ;
54026 int res1 = 0 ;
54027 PyObject *swig_obj[1] ;
54028
54029 if (!args) SWIG_fail;
54030 swig_obj[0] = args;
54031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54032 if (!SWIG_IsOK(res1)) {
54033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54034 }
54035 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54036 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54038 return resultobj;
54039 fail:
54040 return NULL;
54041 }
54042
54043
54044 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54045 PyObject *resultobj = 0;
54046 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54047 wxIndividualLayoutConstraint *result = 0 ;
54048 void *argp1 = 0 ;
54049 int res1 = 0 ;
54050 PyObject *swig_obj[1] ;
54051
54052 if (!args) SWIG_fail;
54053 swig_obj[0] = args;
54054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54055 if (!SWIG_IsOK(res1)) {
54056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54057 }
54058 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54059 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54061 return resultobj;
54062 fail:
54063 return NULL;
54064 }
54065
54066
54067 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54068 PyObject *resultobj = 0;
54069 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54070 wxIndividualLayoutConstraint *result = 0 ;
54071 void *argp1 = 0 ;
54072 int res1 = 0 ;
54073 PyObject *swig_obj[1] ;
54074
54075 if (!args) SWIG_fail;
54076 swig_obj[0] = args;
54077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54078 if (!SWIG_IsOK(res1)) {
54079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54080 }
54081 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54082 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54084 return resultobj;
54085 fail:
54086 return NULL;
54087 }
54088
54089
54090 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54091 PyObject *resultobj = 0;
54092 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54093 wxIndividualLayoutConstraint *result = 0 ;
54094 void *argp1 = 0 ;
54095 int res1 = 0 ;
54096 PyObject *swig_obj[1] ;
54097
54098 if (!args) SWIG_fail;
54099 swig_obj[0] = args;
54100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54101 if (!SWIG_IsOK(res1)) {
54102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54103 }
54104 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54105 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54107 return resultobj;
54108 fail:
54109 return NULL;
54110 }
54111
54112
54113 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54114 PyObject *resultobj = 0;
54115 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54116 wxIndividualLayoutConstraint *result = 0 ;
54117 void *argp1 = 0 ;
54118 int res1 = 0 ;
54119 PyObject *swig_obj[1] ;
54120
54121 if (!args) SWIG_fail;
54122 swig_obj[0] = args;
54123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54124 if (!SWIG_IsOK(res1)) {
54125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54126 }
54127 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54128 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54130 return resultobj;
54131 fail:
54132 return NULL;
54133 }
54134
54135
54136 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54137 PyObject *resultobj = 0;
54138 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54139 wxIndividualLayoutConstraint *result = 0 ;
54140 void *argp1 = 0 ;
54141 int res1 = 0 ;
54142 PyObject *swig_obj[1] ;
54143
54144 if (!args) SWIG_fail;
54145 swig_obj[0] = args;
54146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54147 if (!SWIG_IsOK(res1)) {
54148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54149 }
54150 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54151 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54153 return resultobj;
54154 fail:
54155 return NULL;
54156 }
54157
54158
54159 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54160 PyObject *resultobj = 0;
54161 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54162 wxIndividualLayoutConstraint *result = 0 ;
54163 void *argp1 = 0 ;
54164 int res1 = 0 ;
54165 PyObject *swig_obj[1] ;
54166
54167 if (!args) SWIG_fail;
54168 swig_obj[0] = args;
54169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54170 if (!SWIG_IsOK(res1)) {
54171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54172 }
54173 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54174 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54176 return resultobj;
54177 fail:
54178 return NULL;
54179 }
54180
54181
54182 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54183 PyObject *resultobj = 0;
54184 wxLayoutConstraints *result = 0 ;
54185
54186 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54187 {
54188 PyThreadState* __tstate = wxPyBeginAllowThreads();
54189 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54190 wxPyEndAllowThreads(__tstate);
54191 if (PyErr_Occurred()) SWIG_fail;
54192 }
54193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54194 return resultobj;
54195 fail:
54196 return NULL;
54197 }
54198
54199
54200 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54201 PyObject *resultobj = 0;
54202 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54203 void *argp1 = 0 ;
54204 int res1 = 0 ;
54205 PyObject *swig_obj[1] ;
54206
54207 if (!args) SWIG_fail;
54208 swig_obj[0] = args;
54209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54210 if (!SWIG_IsOK(res1)) {
54211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54212 }
54213 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54214 {
54215 PyThreadState* __tstate = wxPyBeginAllowThreads();
54216 delete arg1;
54217
54218 wxPyEndAllowThreads(__tstate);
54219 if (PyErr_Occurred()) SWIG_fail;
54220 }
54221 resultobj = SWIG_Py_Void();
54222 return resultobj;
54223 fail:
54224 return NULL;
54225 }
54226
54227
54228 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54229 PyObject *resultobj = 0;
54230 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54231 wxWindow *arg2 = (wxWindow *) 0 ;
54232 int *arg3 = (int *) 0 ;
54233 bool result;
54234 void *argp1 = 0 ;
54235 int res1 = 0 ;
54236 void *argp2 = 0 ;
54237 int res2 = 0 ;
54238 int temp3 ;
54239 int res3 = SWIG_TMPOBJ ;
54240 PyObject * obj0 = 0 ;
54241 PyObject * obj1 = 0 ;
54242 char * kwnames[] = {
54243 (char *) "self",(char *) "win", NULL
54244 };
54245
54246 arg3 = &temp3;
54247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54249 if (!SWIG_IsOK(res1)) {
54250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54251 }
54252 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54254 if (!SWIG_IsOK(res2)) {
54255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54256 }
54257 arg2 = reinterpret_cast< wxWindow * >(argp2);
54258 {
54259 PyThreadState* __tstate = wxPyBeginAllowThreads();
54260 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54261 wxPyEndAllowThreads(__tstate);
54262 if (PyErr_Occurred()) SWIG_fail;
54263 }
54264 {
54265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54266 }
54267 if (SWIG_IsTmpObj(res3)) {
54268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54269 } else {
54270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54272 }
54273 return resultobj;
54274 fail:
54275 return NULL;
54276 }
54277
54278
54279 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54280 PyObject *resultobj = 0;
54281 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54282 bool result;
54283 void *argp1 = 0 ;
54284 int res1 = 0 ;
54285 PyObject *swig_obj[1] ;
54286
54287 if (!args) SWIG_fail;
54288 swig_obj[0] = args;
54289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54290 if (!SWIG_IsOK(res1)) {
54291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54292 }
54293 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54294 {
54295 PyThreadState* __tstate = wxPyBeginAllowThreads();
54296 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54297 wxPyEndAllowThreads(__tstate);
54298 if (PyErr_Occurred()) SWIG_fail;
54299 }
54300 {
54301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54302 }
54303 return resultobj;
54304 fail:
54305 return NULL;
54306 }
54307
54308
54309 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54310 PyObject *obj;
54311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54312 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54313 return SWIG_Py_Void();
54314 }
54315
54316 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54317 return SWIG_Python_InitShadowInstance(args);
54318 }
54319
54320 static PyMethodDef SwigMethods[] = {
54321 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54322 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54323 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54324 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54325 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54326 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54327 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54328 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54329 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54331 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54344 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54345 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54346 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54348 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54349 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54350 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54351 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54352 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54353 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54354 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54356 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54362 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54363 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54364 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54365 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54366 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54367 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54368 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54370 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54378 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54379 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54380 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54385 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54386 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54388 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54390 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54392 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54394 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54396 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54398 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54399 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54401 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54403 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54405 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54407 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54408 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54409 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54410 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54430 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54431 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54432 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54433 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54434 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54435 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54436 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54437 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54439 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54440 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54441 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54446 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54447 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54448 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54449 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54450 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54457 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54464 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54465 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54466 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54467 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54469 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54470 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54471 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54473 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54474 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54475 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54476 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54481 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54482 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54483 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54484 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54485 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54486 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54489 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54490 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54491 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54493 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54494 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54496 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54497 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54498 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54499 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54500 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54501 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54502 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54503 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54504 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54505 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54506 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54507 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54512 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54518 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54519 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54520 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54521 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54523 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54526 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54529 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54530 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54532 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54533 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54534 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54537 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54538 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54539 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54543 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54544 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54545 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54549 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54554 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54555 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54556 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54557 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54558 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54559 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54560 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54565 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54567 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54568 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54569 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54570 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54571 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54572 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54578 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54579 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54581 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54582 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54583 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54584 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54585 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54586 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54587 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54588 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54590 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54591 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54592 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54593 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54594 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54595 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54596 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54597 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54599 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54608 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54625 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54626 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54641 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54642 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54643 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54644 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54647 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54649 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54651 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54653 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54655 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54658 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54659 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54660 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54661 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54663 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54665 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54675 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54680 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54681 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54687 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54688 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54690 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54691 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54692 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54693 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54694 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54695 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54696 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54697 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54698 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54699 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54700 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54701 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54702 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54703 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54704 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54705 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54706 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54707 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54708 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54709 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54710 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54711 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54712 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54713 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54714 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54715 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54716 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54717 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54718 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54719 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54720 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54721 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54722 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54724 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54725 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54726 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54727 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54730 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54734 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54736 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54737 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54741 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54742 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54743 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54744 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54746 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54747 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54749 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54751 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54753 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54755 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54756 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54757 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54759 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54760 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54762 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54763 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54764 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54766 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54767 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54768 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54770 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54772 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54773 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54774 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54776 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54778 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54779 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54781 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54782 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54783 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54785 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54786 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54787 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54788 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54789 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54791 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54792 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54795 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54796 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54798 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54799 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54802 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54803 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54805 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54811 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54812 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54813 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54814 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54815 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54816 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54817 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54818 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54819 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54820 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54821 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54822 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54823 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54824 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54825 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54826 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54827 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54828 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54829 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54830 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54831 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54832 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54833 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54834 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54836 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54837 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54838 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54839 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54840 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54841 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54842 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54843 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54844 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54845 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54846 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54847 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54848 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54849 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54850 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54851 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54852 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54853 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54854 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54855 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54856 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54857 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54858 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54859 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54860 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54861 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54862 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54863 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54864 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54865 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54866 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54867 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54869 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54870 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54872 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54873 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54874 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54875 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54877 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54878 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54879 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54880 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54881 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54882 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54883 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54884 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54885 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54887 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54888 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54889 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54890 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54891 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54892 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54893 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54894 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54895 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54896 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54897 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54898 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54899 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54900 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54901 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54902 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54903 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54904 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54905 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54906 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54907 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54908 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54909 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54910 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54911 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54912 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54913 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54914 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54916 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54917 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54920 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54921 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54922 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54923 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54924 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54925 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54927 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54928 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54929 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54931 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54932 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54934 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54935 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54937 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54938 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54940 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54941 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54942 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54944 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54946 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54947 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54949 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54950 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54951 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54953 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54954 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54955 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54957 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54958 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54960 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54961 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54962 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54963 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54964 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54967 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54969 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54971 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54972 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54973 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54976 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54977 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54978 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54980 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54981 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54982 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54984 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54985 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54986 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54987 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54988 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54989 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54991 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54992 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54993 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54994 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54995 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54996 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54997 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54998 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
55004 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
55006 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
55008 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
55009 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
55010 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
55011 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
55012 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
55013 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
55015 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
55016 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
55017 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
55019 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
55020 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
55021 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
55022 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
55023 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
55026 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
55027 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
55028 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55031 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55032 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55033 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55034 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55035 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55037 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55039 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55042 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55044 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55045 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55047 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55048 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55049 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55051 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55052 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55053 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55055 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55057 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55058 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55059 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55061 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55063 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55065 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55066 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55068 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55069 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55071 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55073 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55074 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55075 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55077 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55079 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55080 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55081 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55083 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55085 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55086 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55087 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55088 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55090 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55092 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55094 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55096 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55097 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55099 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55100 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55101 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55102 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55103 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55104 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55105 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55106 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55107 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55109 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55111 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55113 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55115 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55117 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55119 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55120 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55121 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55122 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55123 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55124 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55130 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55131 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55132 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55133 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55134 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55135 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55136 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55137 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55139 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55141 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55142 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55144 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55145 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55146 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55147 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55149 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55150 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55151 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55152 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55154 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55155 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55157 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55158 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55159 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55161 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55164 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55165 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55166 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55167 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55168 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55170 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55171 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55173 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55174 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55175 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55176 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55178 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55179 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55180 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55181 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55182 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55183 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55184 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55185 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55186 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55187 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55189 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55192 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55193 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55194 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55196 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55198 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55200 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55202 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55203 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55206 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55213 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55216 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55217 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55221 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55222 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55223 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55224 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55225 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55226 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55227 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55228 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55229 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55230 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55231 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55232 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55233 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55234 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55235 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55236 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55237 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55238 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55239 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55241 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55242 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55247 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55248 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55250 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55251 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55252 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55253 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55254 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55257 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55258 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55259 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55261 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55263 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55264 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55265 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55266 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55268 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55269 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55270 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55272 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55275 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55276 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55277 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55278 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55279 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55280 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55284 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55285 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55286 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55287 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55294 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55300 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55301 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55302 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55303 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55304 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55306 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55316 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55317 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55318 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55319 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55322 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55323 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55324 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55325 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55326 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55328 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55329 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55330 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55334 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55339 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55340 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55341 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55342 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55343 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55345 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55346 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55348 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55351 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55353 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55354 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55355 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55359 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55362 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55364 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55365 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55368 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55369 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55371 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55373 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55375 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55380 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55381 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55382 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55383 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55384 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55385 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55386 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55388 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55389 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55390 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55391 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55392 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55394 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55395 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55397 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55398 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55399 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55400 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55403 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55405 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55406 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55407 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55408 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55410 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55411 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55416 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55417 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55418 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55420 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55421 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55422 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55424 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55425 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55426 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55427 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55428 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55430 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55431 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55434 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55442 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55448 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55449 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55450 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55451 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55452 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55457 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55460 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55461 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55474 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55476 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55478 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55479 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55481 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55483 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55484 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55485 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55486 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55487 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55488 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55492 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55499 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55502 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55503 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55505 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55509 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55511 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55512 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55513 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55514 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55515 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55517 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55518 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55519 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55521 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55522 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55524 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55525 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55526 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55528 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55529 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55530 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55531 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55534 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55535 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55536 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55537 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55538 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55539 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55541 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55542 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55543 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55544 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55545 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55548 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55550 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55552 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55554 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55555 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55556 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55557 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55559 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55560 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55561 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55563 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55564 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55565 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55566 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55567 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55569 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55570 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55571 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55573 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55574 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55576 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55577 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55578 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55579 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55580 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55582 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55583 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55585 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55586 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55588 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55589 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55590 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55591 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55592 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55593 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55594 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55595 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55596 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55597 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55598 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55600 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55601 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55602 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55603 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55605 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55606 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55611 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55612 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55613 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55614 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55615 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55617 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55619 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55621 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55622 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55624 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55626 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55628 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55629 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55630 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55631 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55633 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55634 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55635 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55639 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55641 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55643 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55644 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55645 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55646 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55647 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55648 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55652 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55653 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55654 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55655 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55656 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55657 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55658 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55659 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55661 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55662 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55663 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55664 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55665 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55666 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55667 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55668 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55669 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55670 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55671 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55672 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55673 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55674 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55675 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55676 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55677 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55678 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55679 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55680 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55681 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55682 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55683 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55684 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55685 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55686 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55687 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55688 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55689 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55690 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55691 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55692 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55693 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55694 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55695 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55696 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55697 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55698 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55699 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55700 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55701 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55702 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55703 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55704 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55705 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55706 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55707 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55708 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55709 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55710 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55711 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55713 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55714 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55715 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55716 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55717 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55718 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55719 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55720 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55721 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55722 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55723 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55724 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55725 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55727 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55729 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55730 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55731 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55732 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55733 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55734 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55735 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55736 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55739 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55740 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55741 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55742 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55743 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55744 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55745 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55746 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55747 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55748 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55750 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55751 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55753 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55756 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55757 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55758 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55759 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55760 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55761 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55762 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55763 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55764 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55765 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55766 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55767 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55768 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55769 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55770 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55771 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55773 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55774 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55775 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55776 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55777 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55778 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55779 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55780 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55781 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55782 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55783 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55784 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55785 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55786 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55787 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55788 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55789 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55790 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55791 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55792 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55793 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55794 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55795 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55796 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55797 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55798 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55799 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55800 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55801 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55802 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55803 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55804 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55805 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55806 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55807 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55808 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55809 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55810 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55811 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55812 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55813 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55814 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55815 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55816 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55817 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55818 { NULL, NULL, 0, NULL }
55819 };
55820
55821
55822 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55823
55824 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55825 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55826 }
55827 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55828 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55829 }
55830 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55831 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55832 }
55833 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55834 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55835 }
55836 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55837 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55838 }
55839 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55840 return (void *)((wxSizer *) ((wxGridSizer *) x));
55841 }
55842 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55843 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55844 }
55845 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55846 return (void *)((wxSizer *) ((wxPySizer *) x));
55847 }
55848 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55849 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55850 }
55851 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55852 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55853 }
55854 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55855 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55856 }
55857 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55858 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55859 }
55860 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55861 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55862 }
55863 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55864 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55865 }
55866 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55867 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55868 }
55869 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55870 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55871 }
55872 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55873 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55874 }
55875 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55876 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55877 }
55878 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55879 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55880 }
55881 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55882 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55883 }
55884 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55885 return (void *)((wxEvent *) ((wxPyEvent *) x));
55886 }
55887 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55888 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55889 }
55890 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55891 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55892 }
55893 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55894 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55895 }
55896 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55897 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55898 }
55899 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55900 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55901 }
55902 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55903 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55904 }
55905 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55906 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55907 }
55908 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55909 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55910 }
55911 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55912 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55913 }
55914 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55915 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55916 }
55917 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55918 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55919 }
55920 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55921 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55922 }
55923 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55924 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55925 }
55926 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55927 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55928 }
55929 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55930 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55931 }
55932 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55933 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55934 }
55935 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55936 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55937 }
55938 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55939 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55940 }
55941 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55942 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55943 }
55944 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55945 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55946 }
55947 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55948 return (void *)((wxEvent *) ((wxShowEvent *) x));
55949 }
55950 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55951 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55952 }
55953 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55954 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55955 }
55956 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55957 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55958 }
55959 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55960 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55961 }
55962 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55963 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55964 }
55965 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55966 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55967 }
55968 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55969 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55970 }
55971 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55972 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55973 }
55974 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55975 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55976 }
55977 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55978 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55979 }
55980 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55981 return (void *)((wxControl *) ((wxControlWithItems *) x));
55982 }
55983 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55984 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55985 }
55986 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55987 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55988 }
55989 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55990 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55991 }
55992 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55993 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55994 }
55995 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55996 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55997 }
55998 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55999 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
56000 }
56001 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
56002 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
56003 }
56004 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
56005 return (void *)((wxEvtHandler *) ((wxMenu *) x));
56006 }
56007 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
56008 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
56009 }
56010 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
56011 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
56012 }
56013 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
56014 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
56015 }
56016 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
56017 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
56018 }
56019 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
56020 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
56021 }
56022 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
56023 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56024 }
56025 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
56026 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
56027 }
56028 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
56029 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56030 }
56031 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56032 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56033 }
56034 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56035 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56036 }
56037 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56038 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56039 }
56040 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56041 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56042 }
56043 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56044 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56045 }
56046 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56047 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56048 }
56049 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56050 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56051 }
56052 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56053 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56054 }
56055 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56056 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56057 }
56058 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56059 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56060 }
56061 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56062 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56063 }
56064 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56065 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56066 }
56067 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56068 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56069 }
56070 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56071 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56072 }
56073 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56075 }
56076 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) ((wxSizerItem *) x));
56078 }
56079 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56081 }
56082 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56084 }
56085 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56087 }
56088 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56090 }
56091 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56093 }
56094 static void *_p_wxSizerTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) ((wxSizer *) x));
56096 }
56097 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56099 }
56100 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56102 }
56103 static void *_p_wxEventTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) ((wxEvent *) x));
56105 }
56106 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56108 }
56109 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56111 }
56112 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56114 }
56115 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56117 }
56118 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56120 }
56121 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56123 }
56124 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56126 }
56127 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56129 }
56130 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56132 }
56133 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56135 }
56136 static void *_p_wxControlTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56138 }
56139 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56141 }
56142 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) ((wxFSFile *) x));
56144 }
56145 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56147 }
56148 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56150 }
56151 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56153 }
56154 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56155 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56156 }
56157 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56158 return (void *)((wxObject *) ((wxMenuItem *) x));
56159 }
56160 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56161 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56162 }
56163 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56164 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56165 }
56166 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56167 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56168 }
56169 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56170 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56171 }
56172 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56173 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56174 }
56175 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56176 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56177 }
56178 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56179 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56180 }
56181 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56182 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56183 }
56184 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56185 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56186 }
56187 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56188 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56189 }
56190 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56191 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56192 }
56193 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56194 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56195 }
56196 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56197 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56198 }
56199 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56200 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56201 }
56202 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56203 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56204 }
56205 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56206 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56207 }
56208 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56209 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56210 }
56211 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56212 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56213 }
56214 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56215 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56216 }
56217 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56218 return (void *)((wxObject *) ((wxImageHandler *) x));
56219 }
56220 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56221 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56222 }
56223 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56224 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56225 }
56226 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56227 return (void *)((wxObject *) ((wxEvtHandler *) x));
56228 }
56229 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56230 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56231 }
56232 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56233 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56234 }
56235 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56236 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56237 }
56238 static void *_p_wxImageTo_p_wxObject(void *x) {
56239 return (void *)((wxObject *) ((wxImage *) x));
56240 }
56241 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56242 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56243 }
56244 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56245 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56246 }
56247 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56248 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56249 }
56250 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56251 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56252 }
56253 static void *_p_wxWindowTo_p_wxObject(void *x) {
56254 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56255 }
56256 static void *_p_wxMenuTo_p_wxObject(void *x) {
56257 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56258 }
56259 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56260 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56261 }
56262 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56263 return (void *)((wxObject *) ((wxFileSystem *) x));
56264 }
56265 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56266 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56267 }
56268 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56269 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56270 }
56271 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56272 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56273 }
56274 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56275 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56276 }
56277 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56278 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56279 }
56280 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56281 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56282 }
56283 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56284 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56285 }
56286 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56287 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56288 }
56289 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56290 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56291 }
56292 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56293 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56294 }
56295 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56296 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56297 }
56298 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56299 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56300 }
56301 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56302 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56303 }
56304 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56305 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56306 }
56307 static void *_p_wxControlTo_p_wxWindow(void *x) {
56308 return (void *)((wxWindow *) ((wxControl *) x));
56309 }
56310 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56311 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56312 }
56313 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56314 return (void *)((wxWindow *) ((wxMenuBar *) x));
56315 }
56316 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56317 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56318 }
56319 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56320 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56321 }
56322 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56323 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56324 }
56325 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56326 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56327 }
56328 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56329 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56330 }
56331 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56332 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56333 }
56334 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56335 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56336 }
56337 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56338 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56339 }
56340 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56341 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56342 }
56343 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56344 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56345 }
56346 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56347 return (void *)((wxValidator *) ((wxPyValidator *) x));
56348 }
56349 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56351 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};
56352 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56451 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56452 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56453 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56454 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56455 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56456 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56457 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56458 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56459 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56460 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56461 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56462 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56463 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56464 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56465 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56466 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56467 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56468 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56469 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56470 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56471 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56472 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56473 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56474 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56475 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56476 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56477 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56478 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56479 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56480 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56481
56482 static swig_type_info *swig_type_initial[] = {
56483 &_swigt__p_buffer,
56484 &_swigt__p_char,
56485 &_swigt__p_form_ops_t,
56486 &_swigt__p_int,
56487 &_swigt__p_long,
56488 &_swigt__p_unsigned_char,
56489 &_swigt__p_unsigned_int,
56490 &_swigt__p_unsigned_long,
56491 &_swigt__p_wxANIHandler,
56492 &_swigt__p_wxAcceleratorEntry,
56493 &_swigt__p_wxAcceleratorTable,
56494 &_swigt__p_wxActivateEvent,
56495 &_swigt__p_wxAppTraits,
56496 &_swigt__p_wxArrayString,
56497 &_swigt__p_wxBMPHandler,
56498 &_swigt__p_wxBitmap,
56499 &_swigt__p_wxBoxSizer,
56500 &_swigt__p_wxButton,
56501 &_swigt__p_wxCURHandler,
56502 &_swigt__p_wxCaret,
56503 &_swigt__p_wxChildFocusEvent,
56504 &_swigt__p_wxClipboardTextEvent,
56505 &_swigt__p_wxCloseEvent,
56506 &_swigt__p_wxColour,
56507 &_swigt__p_wxCommandEvent,
56508 &_swigt__p_wxContextMenuEvent,
56509 &_swigt__p_wxControl,
56510 &_swigt__p_wxControlWithItems,
56511 &_swigt__p_wxCursor,
56512 &_swigt__p_wxDC,
56513 &_swigt__p_wxDateEvent,
56514 &_swigt__p_wxDateTime,
56515 &_swigt__p_wxDisplayChangedEvent,
56516 &_swigt__p_wxDropFilesEvent,
56517 &_swigt__p_wxDuplexMode,
56518 &_swigt__p_wxEraseEvent,
56519 &_swigt__p_wxEvent,
56520 &_swigt__p_wxEventLoop,
56521 &_swigt__p_wxEventLoopActivator,
56522 &_swigt__p_wxEvtHandler,
56523 &_swigt__p_wxFSFile,
56524 &_swigt__p_wxFileSystem,
56525 &_swigt__p_wxFileSystemHandler,
56526 &_swigt__p_wxFlexGridSizer,
56527 &_swigt__p_wxFocusEvent,
56528 &_swigt__p_wxFont,
56529 &_swigt__p_wxFrame,
56530 &_swigt__p_wxGBPosition,
56531 &_swigt__p_wxGBSizerItem,
56532 &_swigt__p_wxGBSpan,
56533 &_swigt__p_wxGIFHandler,
56534 &_swigt__p_wxGridBagSizer,
56535 &_swigt__p_wxGridSizer,
56536 &_swigt__p_wxHelpEvent__Origin,
56537 &_swigt__p_wxICOHandler,
56538 &_swigt__p_wxIconizeEvent,
56539 &_swigt__p_wxIdleEvent,
56540 &_swigt__p_wxImage,
56541 &_swigt__p_wxImageHandler,
56542 &_swigt__p_wxImageHistogram,
56543 &_swigt__p_wxImage_HSVValue,
56544 &_swigt__p_wxImage_RGBValue,
56545 &_swigt__p_wxIndividualLayoutConstraint,
56546 &_swigt__p_wxInitDialogEvent,
56547 &_swigt__p_wxInputStream,
56548 &_swigt__p_wxInternetFSHandler,
56549 &_swigt__p_wxItemContainer,
56550 &_swigt__p_wxJPEGHandler,
56551 &_swigt__p_wxKeyEvent,
56552 &_swigt__p_wxLayoutConstraints,
56553 &_swigt__p_wxMaximizeEvent,
56554 &_swigt__p_wxMemoryFSHandler,
56555 &_swigt__p_wxMenu,
56556 &_swigt__p_wxMenuBar,
56557 &_swigt__p_wxMenuBarBase,
56558 &_swigt__p_wxMenuEvent,
56559 &_swigt__p_wxMenuItem,
56560 &_swigt__p_wxMouseCaptureChangedEvent,
56561 &_swigt__p_wxMouseCaptureLostEvent,
56562 &_swigt__p_wxMouseEvent,
56563 &_swigt__p_wxMoveEvent,
56564 &_swigt__p_wxNavigationKeyEvent,
56565 &_swigt__p_wxNcPaintEvent,
56566 &_swigt__p_wxNotifyEvent,
56567 &_swigt__p_wxObject,
56568 &_swigt__p_wxOutputStream,
56569 &_swigt__p_wxPCXHandler,
56570 &_swigt__p_wxPNGHandler,
56571 &_swigt__p_wxPNMHandler,
56572 &_swigt__p_wxPaintEvent,
56573 &_swigt__p_wxPaletteChangedEvent,
56574 &_swigt__p_wxPaperSize,
56575 &_swigt__p_wxPoint,
56576 &_swigt__p_wxPoint2D,
56577 &_swigt__p_wxPropagateOnce,
56578 &_swigt__p_wxPropagationDisabler,
56579 &_swigt__p_wxPyApp,
56580 &_swigt__p_wxPyCommandEvent,
56581 &_swigt__p_wxPyDropTarget,
56582 &_swigt__p_wxPyEvent,
56583 &_swigt__p_wxPyFileSystemHandler,
56584 &_swigt__p_wxPyImageHandler,
56585 &_swigt__p_wxPyInputStream,
56586 &_swigt__p_wxPySizer,
56587 &_swigt__p_wxPyValidator,
56588 &_swigt__p_wxQuantize,
56589 &_swigt__p_wxQueryNewPaletteEvent,
56590 &_swigt__p_wxRealPoint,
56591 &_swigt__p_wxRect,
56592 &_swigt__p_wxRegion,
56593 &_swigt__p_wxScrollEvent,
56594 &_swigt__p_wxScrollWinEvent,
56595 &_swigt__p_wxSetCursorEvent,
56596 &_swigt__p_wxShowEvent,
56597 &_swigt__p_wxSize,
56598 &_swigt__p_wxSizeEvent,
56599 &_swigt__p_wxSizer,
56600 &_swigt__p_wxSizerItem,
56601 &_swigt__p_wxStaticBox,
56602 &_swigt__p_wxStaticBoxSizer,
56603 &_swigt__p_wxStdDialogButtonSizer,
56604 &_swigt__p_wxSysColourChangedEvent,
56605 &_swigt__p_wxTIFFHandler,
56606 &_swigt__p_wxToolTip,
56607 &_swigt__p_wxUpdateUIEvent,
56608 &_swigt__p_wxValidator,
56609 &_swigt__p_wxVisualAttributes,
56610 &_swigt__p_wxWindow,
56611 &_swigt__p_wxWindowCreateEvent,
56612 &_swigt__p_wxWindowDestroyEvent,
56613 &_swigt__p_wxXPMHandler,
56614 &_swigt__p_wxZipFSHandler,
56615 };
56616
56617 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56624 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56625 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56626 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56627 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56628 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56630 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56631 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}};
56632 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56633 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}};
56634 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56635 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}};
56636 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56639 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56640 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56641 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56643 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}};
56644 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56647 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56648 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56654 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56656 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}};
56657 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56659 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}};
56660 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}};
56661 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56666 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56667 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56669 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}};
56670 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56671 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}};
56672 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56675 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}};
56676 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56683 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}};
56684 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56699 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56713 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56714 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56715 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56716 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56718 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56719 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56720 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56721 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56722 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56723 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56724 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56725 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56726 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56727 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56728 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56729 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56730 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56731 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56732 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56733 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}};
56734 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}};
56735 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56736 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56737 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56738 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56739 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56740 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56741 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56742 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}};
56743 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56744 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}};
56745 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56746 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56747 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56748 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56749
56750 static swig_cast_info *swig_cast_initial[] = {
56751 _swigc__p_buffer,
56752 _swigc__p_char,
56753 _swigc__p_form_ops_t,
56754 _swigc__p_int,
56755 _swigc__p_long,
56756 _swigc__p_unsigned_char,
56757 _swigc__p_unsigned_int,
56758 _swigc__p_unsigned_long,
56759 _swigc__p_wxANIHandler,
56760 _swigc__p_wxAcceleratorEntry,
56761 _swigc__p_wxAcceleratorTable,
56762 _swigc__p_wxActivateEvent,
56763 _swigc__p_wxAppTraits,
56764 _swigc__p_wxArrayString,
56765 _swigc__p_wxBMPHandler,
56766 _swigc__p_wxBitmap,
56767 _swigc__p_wxBoxSizer,
56768 _swigc__p_wxButton,
56769 _swigc__p_wxCURHandler,
56770 _swigc__p_wxCaret,
56771 _swigc__p_wxChildFocusEvent,
56772 _swigc__p_wxClipboardTextEvent,
56773 _swigc__p_wxCloseEvent,
56774 _swigc__p_wxColour,
56775 _swigc__p_wxCommandEvent,
56776 _swigc__p_wxContextMenuEvent,
56777 _swigc__p_wxControl,
56778 _swigc__p_wxControlWithItems,
56779 _swigc__p_wxCursor,
56780 _swigc__p_wxDC,
56781 _swigc__p_wxDateEvent,
56782 _swigc__p_wxDateTime,
56783 _swigc__p_wxDisplayChangedEvent,
56784 _swigc__p_wxDropFilesEvent,
56785 _swigc__p_wxDuplexMode,
56786 _swigc__p_wxEraseEvent,
56787 _swigc__p_wxEvent,
56788 _swigc__p_wxEventLoop,
56789 _swigc__p_wxEventLoopActivator,
56790 _swigc__p_wxEvtHandler,
56791 _swigc__p_wxFSFile,
56792 _swigc__p_wxFileSystem,
56793 _swigc__p_wxFileSystemHandler,
56794 _swigc__p_wxFlexGridSizer,
56795 _swigc__p_wxFocusEvent,
56796 _swigc__p_wxFont,
56797 _swigc__p_wxFrame,
56798 _swigc__p_wxGBPosition,
56799 _swigc__p_wxGBSizerItem,
56800 _swigc__p_wxGBSpan,
56801 _swigc__p_wxGIFHandler,
56802 _swigc__p_wxGridBagSizer,
56803 _swigc__p_wxGridSizer,
56804 _swigc__p_wxHelpEvent__Origin,
56805 _swigc__p_wxICOHandler,
56806 _swigc__p_wxIconizeEvent,
56807 _swigc__p_wxIdleEvent,
56808 _swigc__p_wxImage,
56809 _swigc__p_wxImageHandler,
56810 _swigc__p_wxImageHistogram,
56811 _swigc__p_wxImage_HSVValue,
56812 _swigc__p_wxImage_RGBValue,
56813 _swigc__p_wxIndividualLayoutConstraint,
56814 _swigc__p_wxInitDialogEvent,
56815 _swigc__p_wxInputStream,
56816 _swigc__p_wxInternetFSHandler,
56817 _swigc__p_wxItemContainer,
56818 _swigc__p_wxJPEGHandler,
56819 _swigc__p_wxKeyEvent,
56820 _swigc__p_wxLayoutConstraints,
56821 _swigc__p_wxMaximizeEvent,
56822 _swigc__p_wxMemoryFSHandler,
56823 _swigc__p_wxMenu,
56824 _swigc__p_wxMenuBar,
56825 _swigc__p_wxMenuBarBase,
56826 _swigc__p_wxMenuEvent,
56827 _swigc__p_wxMenuItem,
56828 _swigc__p_wxMouseCaptureChangedEvent,
56829 _swigc__p_wxMouseCaptureLostEvent,
56830 _swigc__p_wxMouseEvent,
56831 _swigc__p_wxMoveEvent,
56832 _swigc__p_wxNavigationKeyEvent,
56833 _swigc__p_wxNcPaintEvent,
56834 _swigc__p_wxNotifyEvent,
56835 _swigc__p_wxObject,
56836 _swigc__p_wxOutputStream,
56837 _swigc__p_wxPCXHandler,
56838 _swigc__p_wxPNGHandler,
56839 _swigc__p_wxPNMHandler,
56840 _swigc__p_wxPaintEvent,
56841 _swigc__p_wxPaletteChangedEvent,
56842 _swigc__p_wxPaperSize,
56843 _swigc__p_wxPoint,
56844 _swigc__p_wxPoint2D,
56845 _swigc__p_wxPropagateOnce,
56846 _swigc__p_wxPropagationDisabler,
56847 _swigc__p_wxPyApp,
56848 _swigc__p_wxPyCommandEvent,
56849 _swigc__p_wxPyDropTarget,
56850 _swigc__p_wxPyEvent,
56851 _swigc__p_wxPyFileSystemHandler,
56852 _swigc__p_wxPyImageHandler,
56853 _swigc__p_wxPyInputStream,
56854 _swigc__p_wxPySizer,
56855 _swigc__p_wxPyValidator,
56856 _swigc__p_wxQuantize,
56857 _swigc__p_wxQueryNewPaletteEvent,
56858 _swigc__p_wxRealPoint,
56859 _swigc__p_wxRect,
56860 _swigc__p_wxRegion,
56861 _swigc__p_wxScrollEvent,
56862 _swigc__p_wxScrollWinEvent,
56863 _swigc__p_wxSetCursorEvent,
56864 _swigc__p_wxShowEvent,
56865 _swigc__p_wxSize,
56866 _swigc__p_wxSizeEvent,
56867 _swigc__p_wxSizer,
56868 _swigc__p_wxSizerItem,
56869 _swigc__p_wxStaticBox,
56870 _swigc__p_wxStaticBoxSizer,
56871 _swigc__p_wxStdDialogButtonSizer,
56872 _swigc__p_wxSysColourChangedEvent,
56873 _swigc__p_wxTIFFHandler,
56874 _swigc__p_wxToolTip,
56875 _swigc__p_wxUpdateUIEvent,
56876 _swigc__p_wxValidator,
56877 _swigc__p_wxVisualAttributes,
56878 _swigc__p_wxWindow,
56879 _swigc__p_wxWindowCreateEvent,
56880 _swigc__p_wxWindowDestroyEvent,
56881 _swigc__p_wxXPMHandler,
56882 _swigc__p_wxZipFSHandler,
56883 };
56884
56885
56886 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56887
56888 static swig_const_info swig_const_table[] = {
56889 {0, 0, 0, 0.0, 0, 0}};
56890
56891 #ifdef __cplusplus
56892 }
56893 #endif
56894 /* -----------------------------------------------------------------------------
56895 * Type initialization:
56896 * This problem is tough by the requirement that no dynamic
56897 * memory is used. Also, since swig_type_info structures store pointers to
56898 * swig_cast_info structures and swig_cast_info structures store pointers back
56899 * to swig_type_info structures, we need some lookup code at initialization.
56900 * The idea is that swig generates all the structures that are needed.
56901 * The runtime then collects these partially filled structures.
56902 * The SWIG_InitializeModule function takes these initial arrays out of
56903 * swig_module, and does all the lookup, filling in the swig_module.types
56904 * array with the correct data and linking the correct swig_cast_info
56905 * structures together.
56906 *
56907 * The generated swig_type_info structures are assigned staticly to an initial
56908 * array. We just loop though that array, and handle each type individually.
56909 * First we lookup if this type has been already loaded, and if so, use the
56910 * loaded structure instead of the generated one. Then we have to fill in the
56911 * cast linked list. The cast data is initially stored in something like a
56912 * two-dimensional array. Each row corresponds to a type (there are the same
56913 * number of rows as there are in the swig_type_initial array). Each entry in
56914 * a column is one of the swig_cast_info structures for that type.
56915 * The cast_initial array is actually an array of arrays, because each row has
56916 * a variable number of columns. So to actually build the cast linked list,
56917 * we find the array of casts associated with the type, and loop through it
56918 * adding the casts to the list. The one last trick we need to do is making
56919 * sure the type pointer in the swig_cast_info struct is correct.
56920 *
56921 * First off, we lookup the cast->type name to see if it is already loaded.
56922 * There are three cases to handle:
56923 * 1) If the cast->type has already been loaded AND the type we are adding
56924 * casting info to has not been loaded (it is in this module), THEN we
56925 * replace the cast->type pointer with the type pointer that has already
56926 * been loaded.
56927 * 2) If BOTH types (the one we are adding casting info to, and the
56928 * cast->type) are loaded, THEN the cast info has already been loaded by
56929 * the previous module so we just ignore it.
56930 * 3) Finally, if cast->type has not already been loaded, then we add that
56931 * swig_cast_info to the linked list (because the cast->type) pointer will
56932 * be correct.
56933 * ----------------------------------------------------------------------------- */
56934
56935 #ifdef __cplusplus
56936 extern "C" {
56937 #if 0
56938 } /* c-mode */
56939 #endif
56940 #endif
56941
56942 #if 0
56943 #define SWIGRUNTIME_DEBUG
56944 #endif
56945
56946 SWIGRUNTIME void
56947 SWIG_InitializeModule(void *clientdata) {
56948 size_t i;
56949 swig_module_info *module_head;
56950 static int init_run = 0;
56951
56952 clientdata = clientdata;
56953
56954 if (init_run) return;
56955 init_run = 1;
56956
56957 /* Initialize the swig_module */
56958 swig_module.type_initial = swig_type_initial;
56959 swig_module.cast_initial = swig_cast_initial;
56960
56961 /* Try and load any already created modules */
56962 module_head = SWIG_GetModule(clientdata);
56963 if (module_head) {
56964 swig_module.next = module_head->next;
56965 module_head->next = &swig_module;
56966 } else {
56967 /* This is the first module loaded */
56968 swig_module.next = &swig_module;
56969 SWIG_SetModule(clientdata, &swig_module);
56970 }
56971
56972 /* Now work on filling in swig_module.types */
56973 #ifdef SWIGRUNTIME_DEBUG
56974 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56975 #endif
56976 for (i = 0; i < swig_module.size; ++i) {
56977 swig_type_info *type = 0;
56978 swig_type_info *ret;
56979 swig_cast_info *cast;
56980
56981 #ifdef SWIGRUNTIME_DEBUG
56982 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56983 #endif
56984
56985 /* if there is another module already loaded */
56986 if (swig_module.next != &swig_module) {
56987 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56988 }
56989 if (type) {
56990 /* Overwrite clientdata field */
56991 #ifdef SWIGRUNTIME_DEBUG
56992 printf("SWIG_InitializeModule: found type %s\n", type->name);
56993 #endif
56994 if (swig_module.type_initial[i]->clientdata) {
56995 type->clientdata = swig_module.type_initial[i]->clientdata;
56996 #ifdef SWIGRUNTIME_DEBUG
56997 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56998 #endif
56999 }
57000 } else {
57001 type = swig_module.type_initial[i];
57002 }
57003
57004 /* Insert casting types */
57005 cast = swig_module.cast_initial[i];
57006 while (cast->type) {
57007 /* Don't need to add information already in the list */
57008 ret = 0;
57009 #ifdef SWIGRUNTIME_DEBUG
57010 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
57011 #endif
57012 if (swig_module.next != &swig_module) {
57013 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
57014 #ifdef SWIGRUNTIME_DEBUG
57015 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
57016 #endif
57017 }
57018 if (ret) {
57019 if (type == swig_module.type_initial[i]) {
57020 #ifdef SWIGRUNTIME_DEBUG
57021 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
57022 #endif
57023 cast->type = ret;
57024 ret = 0;
57025 } else {
57026 /* Check for casting already in the list */
57027 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
57028 #ifdef SWIGRUNTIME_DEBUG
57029 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57030 #endif
57031 if (!ocast) ret = 0;
57032 }
57033 }
57034
57035 if (!ret) {
57036 #ifdef SWIGRUNTIME_DEBUG
57037 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57038 #endif
57039 if (type->cast) {
57040 type->cast->prev = cast;
57041 cast->next = type->cast;
57042 }
57043 type->cast = cast;
57044 }
57045 cast++;
57046 }
57047 /* Set entry in modules->types array equal to the type */
57048 swig_module.types[i] = type;
57049 }
57050 swig_module.types[i] = 0;
57051
57052 #ifdef SWIGRUNTIME_DEBUG
57053 printf("**** SWIG_InitializeModule: Cast List ******\n");
57054 for (i = 0; i < swig_module.size; ++i) {
57055 int j = 0;
57056 swig_cast_info *cast = swig_module.cast_initial[i];
57057 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57058 while (cast->type) {
57059 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57060 cast++;
57061 ++j;
57062 }
57063 printf("---- Total casts: %d\n",j);
57064 }
57065 printf("**** SWIG_InitializeModule: Cast List ******\n");
57066 #endif
57067 }
57068
57069 /* This function will propagate the clientdata field of type to
57070 * any new swig_type_info structures that have been added into the list
57071 * of equivalent types. It is like calling
57072 * SWIG_TypeClientData(type, clientdata) a second time.
57073 */
57074 SWIGRUNTIME void
57075 SWIG_PropagateClientData(void) {
57076 size_t i;
57077 swig_cast_info *equiv;
57078 static int init_run = 0;
57079
57080 if (init_run) return;
57081 init_run = 1;
57082
57083 for (i = 0; i < swig_module.size; i++) {
57084 if (swig_module.types[i]->clientdata) {
57085 equiv = swig_module.types[i]->cast;
57086 while (equiv) {
57087 if (!equiv->converter) {
57088 if (equiv->type && !equiv->type->clientdata)
57089 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57090 }
57091 equiv = equiv->next;
57092 }
57093 }
57094 }
57095 }
57096
57097 #ifdef __cplusplus
57098 #if 0
57099 {
57100 /* c-mode */
57101 #endif
57102 }
57103 #endif
57104
57105
57106
57107 #ifdef __cplusplus
57108 extern "C" {
57109 #endif
57110
57111 /* Python-specific SWIG API */
57112 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57113 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57114 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57115
57116 /* -----------------------------------------------------------------------------
57117 * global variable support code.
57118 * ----------------------------------------------------------------------------- */
57119
57120 typedef struct swig_globalvar {
57121 char *name; /* Name of global variable */
57122 PyObject *(*get_attr)(void); /* Return the current value */
57123 int (*set_attr)(PyObject *); /* Set the value */
57124 struct swig_globalvar *next;
57125 } swig_globalvar;
57126
57127 typedef struct swig_varlinkobject {
57128 PyObject_HEAD
57129 swig_globalvar *vars;
57130 } swig_varlinkobject;
57131
57132 SWIGINTERN PyObject *
57133 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57134 return PyString_FromString("<Swig global variables>");
57135 }
57136
57137 SWIGINTERN PyObject *
57138 swig_varlink_str(swig_varlinkobject *v) {
57139 PyObject *str = PyString_FromString("(");
57140 swig_globalvar *var;
57141 for (var = v->vars; var; var=var->next) {
57142 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57143 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57144 }
57145 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57146 return str;
57147 }
57148
57149 SWIGINTERN int
57150 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57151 PyObject *str = swig_varlink_str(v);
57152 fprintf(fp,"Swig global variables ");
57153 fprintf(fp,"%s\n", PyString_AsString(str));
57154 Py_DECREF(str);
57155 return 0;
57156 }
57157
57158 SWIGINTERN void
57159 swig_varlink_dealloc(swig_varlinkobject *v) {
57160 swig_globalvar *var = v->vars;
57161 while (var) {
57162 swig_globalvar *n = var->next;
57163 free(var->name);
57164 free(var);
57165 var = n;
57166 }
57167 }
57168
57169 SWIGINTERN PyObject *
57170 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57171 PyObject *res = NULL;
57172 swig_globalvar *var = v->vars;
57173 while (var) {
57174 if (strcmp(var->name,n) == 0) {
57175 res = (*var->get_attr)();
57176 break;
57177 }
57178 var = var->next;
57179 }
57180 if (res == NULL && !PyErr_Occurred()) {
57181 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57182 }
57183 return res;
57184 }
57185
57186 SWIGINTERN int
57187 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57188 int res = 1;
57189 swig_globalvar *var = v->vars;
57190 while (var) {
57191 if (strcmp(var->name,n) == 0) {
57192 res = (*var->set_attr)(p);
57193 break;
57194 }
57195 var = var->next;
57196 }
57197 if (res == 1 && !PyErr_Occurred()) {
57198 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57199 }
57200 return res;
57201 }
57202
57203 SWIGINTERN PyTypeObject*
57204 swig_varlink_type(void) {
57205 static char varlink__doc__[] = "Swig var link object";
57206 static PyTypeObject varlink_type;
57207 static int type_init = 0;
57208 if (!type_init) {
57209 const PyTypeObject tmp
57210 = {
57211 PyObject_HEAD_INIT(NULL)
57212 0, /* Number of items in variable part (ob_size) */
57213 (char *)"swigvarlink", /* Type name (tp_name) */
57214 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57215 0, /* Itemsize (tp_itemsize) */
57216 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57217 (printfunc) swig_varlink_print, /* Print (tp_print) */
57218 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57219 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57220 0, /* tp_compare */
57221 (reprfunc) swig_varlink_repr, /* tp_repr */
57222 0, /* tp_as_number */
57223 0, /* tp_as_sequence */
57224 0, /* tp_as_mapping */
57225 0, /* tp_hash */
57226 0, /* tp_call */
57227 (reprfunc)swig_varlink_str, /* tp_str */
57228 0, /* tp_getattro */
57229 0, /* tp_setattro */
57230 0, /* tp_as_buffer */
57231 0, /* tp_flags */
57232 varlink__doc__, /* tp_doc */
57233 0, /* tp_traverse */
57234 0, /* tp_clear */
57235 0, /* tp_richcompare */
57236 0, /* tp_weaklistoffset */
57237 #if PY_VERSION_HEX >= 0x02020000
57238 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57239 #endif
57240 #if PY_VERSION_HEX >= 0x02030000
57241 0, /* tp_del */
57242 #endif
57243 #ifdef COUNT_ALLOCS
57244 0,0,0,0 /* tp_alloc -> tp_next */
57245 #endif
57246 };
57247 varlink_type = tmp;
57248 varlink_type.ob_type = &PyType_Type;
57249 type_init = 1;
57250 }
57251 return &varlink_type;
57252 }
57253
57254 /* Create a variable linking object for use later */
57255 SWIGINTERN PyObject *
57256 SWIG_Python_newvarlink(void) {
57257 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57258 if (result) {
57259 result->vars = 0;
57260 }
57261 return ((PyObject*) result);
57262 }
57263
57264 SWIGINTERN void
57265 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57266 swig_varlinkobject *v = (swig_varlinkobject *) p;
57267 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57268 if (gv) {
57269 size_t size = strlen(name)+1;
57270 gv->name = (char *)malloc(size);
57271 if (gv->name) {
57272 strncpy(gv->name,name,size);
57273 gv->get_attr = get_attr;
57274 gv->set_attr = set_attr;
57275 gv->next = v->vars;
57276 }
57277 }
57278 v->vars = gv;
57279 }
57280
57281 SWIGINTERN PyObject *
57282 SWIG_globals() {
57283 static PyObject *_SWIG_globals = 0;
57284 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57285 return _SWIG_globals;
57286 }
57287
57288 /* -----------------------------------------------------------------------------
57289 * constants/methods manipulation
57290 * ----------------------------------------------------------------------------- */
57291
57292 /* Install Constants */
57293 SWIGINTERN void
57294 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57295 PyObject *obj = 0;
57296 size_t i;
57297 for (i = 0; constants[i].type; ++i) {
57298 switch(constants[i].type) {
57299 case SWIG_PY_POINTER:
57300 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57301 break;
57302 case SWIG_PY_BINARY:
57303 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57304 break;
57305 default:
57306 obj = 0;
57307 break;
57308 }
57309 if (obj) {
57310 PyDict_SetItemString(d, constants[i].name, obj);
57311 Py_DECREF(obj);
57312 }
57313 }
57314 }
57315
57316 /* -----------------------------------------------------------------------------*/
57317 /* Fix SwigMethods to carry the callback ptrs when needed */
57318 /* -----------------------------------------------------------------------------*/
57319
57320 SWIGINTERN void
57321 SWIG_Python_FixMethods(PyMethodDef *methods,
57322 swig_const_info *const_table,
57323 swig_type_info **types,
57324 swig_type_info **types_initial) {
57325 size_t i;
57326 for (i = 0; methods[i].ml_name; ++i) {
57327 const char *c = methods[i].ml_doc;
57328 if (c && (c = strstr(c, "swig_ptr: "))) {
57329 int j;
57330 swig_const_info *ci = 0;
57331 const char *name = c + 10;
57332 for (j = 0; const_table[j].type; ++j) {
57333 if (strncmp(const_table[j].name, name,
57334 strlen(const_table[j].name)) == 0) {
57335 ci = &(const_table[j]);
57336 break;
57337 }
57338 }
57339 if (ci) {
57340 size_t shift = (ci->ptype) - types;
57341 swig_type_info *ty = types_initial[shift];
57342 size_t ldoc = (c - methods[i].ml_doc);
57343 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57344 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57345 if (ndoc) {
57346 char *buff = ndoc;
57347 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57348 if (ptr) {
57349 strncpy(buff, methods[i].ml_doc, ldoc);
57350 buff += ldoc;
57351 strncpy(buff, "swig_ptr: ", 10);
57352 buff += 10;
57353 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57354 methods[i].ml_doc = ndoc;
57355 }
57356 }
57357 }
57358 }
57359 }
57360 }
57361
57362 #ifdef __cplusplus
57363 }
57364 #endif
57365
57366 /* -----------------------------------------------------------------------------*
57367 * Partial Init method
57368 * -----------------------------------------------------------------------------*/
57369
57370 #ifdef __cplusplus
57371 extern "C"
57372 #endif
57373 SWIGEXPORT void SWIG_init(void) {
57374 PyObject *m, *d;
57375
57376 /* Fix SwigMethods to carry the callback ptrs when needed */
57377 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57378
57379 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57380 d = PyModule_GetDict(m);
57381
57382 SWIG_InitializeModule(0);
57383 SWIG_InstallConstants(d,swig_const_table);
57384
57385
57386
57387 #ifndef wxPyUSE_EXPORT
57388 // Make our API structure a CObject so other modules can import it
57389 // from this module.
57390 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57391 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57392 Py_XDECREF(cobj);
57393 #endif
57394
57395 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57396 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57397 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57398 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57399 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57400 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57401 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57402 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57403 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57404 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57405 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57406 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57407 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57408 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57409 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57410 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57411 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57412 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57413 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57414 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57415 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57416 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57417 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57418 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57419 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57420 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57421 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57422 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57423 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57424 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57425 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57426 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57427 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57428 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57429 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57430 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57431 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57432 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57433 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57434 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57435 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57436 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57437 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57438 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57439 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57440 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57441 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57442 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57443 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57444 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57445 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57446 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57447 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57448 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57449 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57450 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57451 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57452 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57453 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57454 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57455 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57456 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57457 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57458 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57459 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57460 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57461 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57462 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57463 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57464 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57465 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57466 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57467 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57468 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57469 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57470 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57471 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57472 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57473 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57474 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57475 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57476 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57477 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57478 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57479 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57480 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57481 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57482 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57483 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57484 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57485 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57486 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57487 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57488 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57489 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57490 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57491 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57492 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57493 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57494 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57495 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57496 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57497 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57498 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57499 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57500 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57501 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57502 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57503 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57504 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57505 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57506 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57507 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57508 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57509 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57510 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57511 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57512 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57513 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57514 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57515 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57516 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57517 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57518 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57519 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57520 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57521 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57522 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57523 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57524 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57525 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57526 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57527 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57528 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57529 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57530 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57531 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57532 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57533 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57534 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57535 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57536 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57537 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57538 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57539 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57540 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57541 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57542 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57543 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57544 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57545 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57546 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57547 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57548 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57549 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57550 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57551 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57552 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57553 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57554 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57555 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57556 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57557 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57558 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57559 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57560 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57561 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57562 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57563 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57564 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57565 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57566 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57567 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57568 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57569 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57570 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57571 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57572 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57573 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57574 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57575 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57576 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57577 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57578 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57579 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57580 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57581 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57582 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57583 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57584 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57585 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57586 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57587 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57588 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57589 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57590 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57591 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57592 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57593 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57594 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57595 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57596 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57597 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57598 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57599 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57600 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57601 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57602 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57603 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57604 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57605 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57606 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57607 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57608 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57609 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57610 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57611 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57612 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57613 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57614 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57615 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57616 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57617 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57618 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57619 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57620 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57621 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57622 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57623 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57624 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57625 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57626 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57627 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57628 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57629 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57630 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57631 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57632 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57633 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57634 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57635 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57636 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57637 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57638 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57639 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57640 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57641 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57642 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57643 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57644 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57645 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57646 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57647 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57648 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57649 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57650 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57651 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57652 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57653 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57654 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57655 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57656 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57657 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57658 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57659 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57660 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57661 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57662 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57663 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57664 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57665 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57666 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57667 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57668 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57669 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57670 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57671 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57672 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57673 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57674 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57675 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57676 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57677 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57678 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57679 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57680 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57681 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57682 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57683 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57684 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57685 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57686 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57687 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57688 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57689 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57690 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57691 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57692 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57693 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57694 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57695 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57696 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57697 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57698 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57699 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57700 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57701 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57702 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57703 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57704 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57705 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57706 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57707 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57708 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57709 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57710 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57711 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57712 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57713 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57714 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57715 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57716 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57717 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57718 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57719 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57720 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57721 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57722 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57723 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57724 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57725 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57726 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57727 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57728 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57729 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57730 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57731 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57732 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57733 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57734 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57735 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57736 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57737 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57738 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57739 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57740 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57741 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57742 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57743 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57744 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57745 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57746 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57747 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57748 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57749 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57750 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57751 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57752 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57753 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57754 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57755 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57756 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57757 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57758 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57759 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57760 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57761 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57762 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57763 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57764 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57765 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57766 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57767 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57768 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57769 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57770 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57771 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57772 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57773 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57774 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57775 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57776 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57777 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57778 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57779 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57780 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57781 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57782 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57783 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57784 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57785 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57786 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57787 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57788 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57789 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57790 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57791 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57792 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57793 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57794 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57795 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57796 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57797 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57798 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57799 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57800 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57801 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57807 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57808 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57809 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57810 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57811 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57812 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57813 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57814 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57815 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57816 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57817 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57818 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57819 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57820 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57821 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57822 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57823 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57824 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57825 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57826 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57827 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57828 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57829 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57830 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57831 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57832 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57833 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57834 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57835 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57836 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57837 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57838 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57839 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57840 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57841 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57842 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57843 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57844 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57845 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57846 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57847 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57848 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57849 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57850 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57851 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57852 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57853 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57854 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57855 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57856 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57857 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57858 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57859 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57860 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57861 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57862 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57863 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57864 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57865 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57866 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57867 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57868 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57869 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57870 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57871 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57872 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57873 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57874 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57875 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57876 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57877 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57878 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57879 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57880 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57881 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57882 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57883 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57884 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57885 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57886 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57887 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57888 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57889 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57890 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57891 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57892 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57893 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57894 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57895 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57896 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57897 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57898 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57899 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57900 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57901 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57902 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57903 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57904 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57905 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57906 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57907 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57908 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57909 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57910 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57911 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57912 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57913 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57914 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57923 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57924 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57925 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57926 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57927 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57928 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57929 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57930 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57931 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57932 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57933 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57934 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57935 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57936 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57937 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57938 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57939 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57940 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57941 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57942 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57943 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57944 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57945 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57946 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57947 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57948 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57949 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57950 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57951 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57952 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57953 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57954 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57955 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57956 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57957 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57958 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57959 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57960 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57961 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57962 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57963 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57964 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57965 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57966 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57967 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57968 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57969 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57970 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57971 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57972 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57973 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57974 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57975 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57976 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57977 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57978 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57979 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57980 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57981 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57982 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57983 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57984 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57985 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57986 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57987 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57988 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57989 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57990 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57991 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57992 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57993 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57994 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57995 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57996 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57997 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57998 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57999 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
58000 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
58001 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
58002 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
58003 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
58004 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
58005 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
58006 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
58007 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
58008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
58009 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
58010 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
58011 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
58012 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
58013 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
58014 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
58015 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
58016 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
58017 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
58018 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
58019 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
58020 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
58021 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
58022 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
58023 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
58024 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
58025 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
58026 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
58027 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
58028 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
58029 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58030 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58031 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58032 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58033 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58034 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58035 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58036 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58037 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58038 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58039 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58040 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58041 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58042 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58043 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58044 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58045 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58046 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58047 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58048 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58049 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58050 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58051 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58052 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58053 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58054
58055 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58056
58057
58058 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58059
58060 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58061 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58062 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58063 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58064 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58065 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58066 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58067 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58068 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58069 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58070 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58071 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58072 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58073 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58074 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58075 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58076 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58077 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58078 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58079 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58080 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58081 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58082 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58083 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58084 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58085 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58086 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58087 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58088 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58089 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58090 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58091 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58092 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58093 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58094 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58095 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58096 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58097 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58098 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58099 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58100 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58101 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58102 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58103 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58104 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58105 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58106 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58107 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58108 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58109 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58110 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58111 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58112 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58113 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58114 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58115 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58116 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58117 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58118 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58119 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58120 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58121 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58122 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58123 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58124 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58125 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58126 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58127 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58128 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58129 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58130 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58131 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58132 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58133 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58134 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58135 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58136 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58137 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58138 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58139 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58140 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58141 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58142 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58143 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58144 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58145 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58146 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58147 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58148 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58149 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58150 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58151 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58152 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58153 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58154 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58155 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58156 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58157 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58158 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58159 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58160 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58161 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58162 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58163 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58164 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58165 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58166 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58167 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58168 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58169 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58170 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58171 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58172 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58173 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58174 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58175 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58176 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58177 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58178 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58179 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58180 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58181 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58182 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58183 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58184 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58185 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58186 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58187 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58188 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58189 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58190 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58191 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58192 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58193 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58194 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58195 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58196 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58197 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58198 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58199 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58200 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58201 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58202 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58203 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58204 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58205 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58206 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58207 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58208 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58209 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58210 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58211 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58212 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58213 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58214 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58215 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58216 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58217 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58218 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58219 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58220 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58221 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58222 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58223 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58224 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58225 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58226 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58227 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58228 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58229 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58230 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58231 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58232 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58233 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58234 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58235 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58236 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58237 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58238 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58239 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58240 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58241 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58242 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58243 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58244 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58245 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58246 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58247 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58248 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58249 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58250 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58251 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58252 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58253 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58254 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58255 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58256 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58257 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58258 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58259 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58260 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58261 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58262 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58263 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58264 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58265 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58266 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58267 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58268 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58269 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58270 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58271 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58272 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58273 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58274
58275 // Initialize threading, some globals and such
58276 __wxPyPreStart(d);
58277
58278
58279 // Although these are defined in __version__ they need to be here too so
58280 // that an assert can be done to ensure that the wxPython and the wxWindows
58281 // versions match.
58282 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58283 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58284 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58285
58286 }
58287
wxWidgets (Impactor)